What Programming Languages Does TaxHacker Use? A Full-Stack Breakdown

TaxHacker is built primarily with TypeScript and JavaScript, using the Prisma schema language for database definitions and Docker configuration files for deployment.

TaxHacker is a full-stack open-source tax management application. According to the vas3k/TaxHacker source code, the codebase is a modern Node.js application where TypeScript serves as the primary development language, supplemented by domain-specific languages for data modeling and infrastructure configuration.

Core Application Languages

TaxHacker's business logic and user interface are written in JavaScript ecosystem languages compiled for Node.js runtime execution.

TypeScript (Primary Language)

TypeScript dominates the codebase, appearing in .ts and .tsx files throughout the repository. The core application logic resides in files like models/users.ts and lib/utils.ts, while the Next.js frontend components use TSX files such as app/page.tsx and various files under components/.

The project uses TypeScript for static typing, better editor support, and safe refactoring while compiling to modern JavaScript.

JavaScript (ES Modules)

While TypeScript is primary, the project declares itself as an ES Module via "type": "module" in package.json. This allows seamless interoperability with the broader Node.js ecosystem using standard ES-module import syntax for third-party modules and runtime code.

Database and Schema Languages

Beyond the application code, TaxHacker employs specialized languages for data persistence and styling.

Prisma Schema Language

The database layer uses Prisma's declarative DSL defined in prisma/schema.prisma. This schema language compiles into SQL migrations and generates a type-safe client for database operations.

Key models are defined using this syntax, which Prisma then translates into PostgreSQL-compatible SQL for migration files stored under prisma/migrations/.

Tailwind CSS Configuration

Styling configuration authored in TypeScript appears in tailwind.config.ts. This keeps the styling setup type-checked and consistent with the rest of the codebase, leveraging Tailwind's utility-first approach within a TypeScript environment.

Deployment and Infrastructure

Containerization and orchestration use standard configuration syntaxes that contain shell-style commands.

Docker and Docker Compose

The Dockerfile and docker-compose.yml provide reproducible deployment configurations. These files contain bash-style instructions for building container images and orchestrating the application with PostgreSQL, though they are not part of the runtime application code.

Code Examples in Action

The following examples demonstrate how these languages work together in the TaxHacker codebase.

TypeScript Database Client

In lib/db.ts, the Prisma client is instantiated and wrapped for type-safe database access:

// lib/db.ts – a thin wrapper around the Prisma client
import { PrismaClient } from '@prisma/client';

export const db = new PrismaClient();

// Example: fetch all transactions for a user
export async function getUserTransactions(userId: string) {
  return await db.transaction.findMany({
    where: { userId },
    orderBy: { date: 'desc' },
  });
}

React Component (TSX)

Frontend components consume the typed API using TSX syntax, as seen in transaction handling logic:

import { useEffect, useState } from 'react';
import { getUserTransactions } from '@/lib/db';

export default function TransactionList({ userId }: { userId: string }) {
  const [transactions, setTransactions] = useState<any[]>([]);

  useEffect(() => {
    getUserTransactions(userId).then(setTransactions);
  }, [userId]);

  return (
    <ul>
      {transactions.map((t) => (
        <li key={t.id}>{t.description}: ${t.amount}</li>
      ))}
    </ul>
  );
}

Prisma Schema Definition

The database models are declared using Prisma's schema language in prisma/schema.prisma:

model Transaction {
  id          String   @id @default(uuid())
  userId      String
  amount      Float
  currency    String
  description String?
  date        DateTime @default(now())
  // …other fields
}

Key Files by Language

These critical files demonstrate the language distribution across the TaxHacker repository:

• package.json – Declares the project as an ES Module and lists Node.js dependencies
• tsconfig.json – TypeScript compiler configuration for the entire codebase
• tailwind.config.ts – Tailwind CSS configuration written in TypeScript
• next.config.ts – Next.js framework configuration using TypeScript
• models/*.ts, lib/*.ts, app/**/*.tsx – Core business logic and React components written in TypeScript/TSX
• prisma/schema.prisma – Declarative database model definitions using Prisma DSL
• Dockerfile and docker-compose.yml – Container orchestration using Dockerfile syntax

Summary

• TypeScript is the dominant language for application logic, API routes, and React components in TaxHacker.
• JavaScript (ES Modules) provides interoperability with the Node.js ecosystem as declared in package.json.
• Prisma schema language defines database structures in prisma/schema.prisma and auto-generates SQL migrations.
• Tailwind CSS configuration leverages TypeScript for type-safe styling setup in tailwind.config.ts.
• Docker configuration files handle deployment using standard container definition syntax.

Frequently Asked Questions

Is TaxHacker written entirely in TypeScript?

No, while TypeScript is the primary development language for application code, TaxHacker also uses the Prisma schema language for database definitions and Docker configuration files for deployment. The project is configured as an ES Module in package.json, allowing seamless integration with JavaScript libraries.

What database language does TaxHacker use?

TaxHacker uses Prisma's schema language to define database models in prisma/schema.prisma. This declarative DSL compiles into SQL that Prisma uses to generate migration files under prisma/migrations/ and creates a type-safe client for PostgreSQL operations.

Does TaxHacker use JavaScript or TypeScript for configuration?

TaxHacker uses TypeScript for most configuration files, including tailwind.config.ts and next.config.ts. This approach ensures type checking and consistency across the codebase, though some third-party modules rely on standard JavaScript ES modules for runtime compatibility.

Where is the core business logic located in TaxHacker?

The core business logic resides in TypeScript files under models/ and lib/, such as models/users.ts and lib/utils.ts, while React components and API routes use TSX files in the app/ directory and components/ folder.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}