How are Postgres ENUM types handled?

A CREATE TYPE ... AS ENUM becomes a TypeScript literal union in its own .enum.ts file, and every column declared with that type imports the union. Narrowing and exhaustive switch checks work without casts.

How are nullable columns typed?

A column without NOT NULL is emitted as ?: T | null — both optional on the object and nullable on the value. A NOT NULL column is required and non-null. There is no fallback to string for unknowns.

Does it generate queries, a repository, or an ORM layer?

No, and that is deliberate. The output is types. You bring the driver — pg, mysql2, postgres, whatever — and write the SQL. The emitted interface is the row generic, so your queries are typed without a runtime attached.

Does it support foreign-key navigation properties?

Yes, opt-in via a flag. With it on, the generator adds a customer?: Customers on the child interface and an orders?: Array<Orders> on the parent. Both are optional — populate them when your query joins, omit them when it doesn't. Off by default — the baseline output stays lean.

Which SQL dialects are supported?

The parser auto-detects the dialect from the DDL and handles PostgreSQL, MySQL, SQL Server, and SQLite (with a generic fallback for vanilla CREATE TABLE). Common column types — UUID, VARCHAR, TEXT, INTEGER, DECIMAL, DATE, TIMESTAMP, CHAR — map cleanly across all four. Postgres CREATE TYPE ... AS ENUM is the canonical path for literal-union output. Foreign-key constraints are read for navigation properties.

Can I run this from Claude or Cursor?

Yes, via the MCP server above. It wraps the same web API the converter uses, so output parity is guaranteed. Free to use, no API token.

Yes, MIT-licensed. The browser converter, the MCP server, and the generated code are all free. No paid tier, no hosted-only feature.

SQL DDL·TypeScript·Free

SQL DDL to
TypeScript.

Paste CREATE TABLE statements, get typed TypeScript interfaces. Postgres ENUM types become literal unions. Nullable columns land as ?: T | null. Timestamps as Date. One file per table. No ORM, no runtime — just types you can use with any driver.

Open the converter Or run it from Claude

Postgres·MySQL·SQL Server·SQLite·MIT

schema.sqlInput

CREATE TYPE payment_status AS ENUM (
  'pending', 'authorized', 'captured', 'refunded', 'failed'
);

CREATE TABLE payments (
  id            UUID PRIMARY KEY,
  customer_id   UUID NOT NULL,
  amount_cents  INTEGER NOT NULL,
  currency      CHAR(3) NOT NULL,
  status        payment_status NOT NULL,
  description   TEXT,
  captured_at   TIMESTAMP,
  created_at    TIMESTAMP NOT NULL
);

compile

src/models/payments.ts tsc cleanOutput

// src/models/payment-status.enum.ts
export type PaymentStatus =
  | 'pending'
  | 'authorized'
  | 'captured'
  | 'refunded'
  | 'failed';

// src/models/payments.ts
import { PaymentStatus } from './payment-status.enum';

export interface Payments {
  id: string;
  customerId: string;
  amountCents: number;
  currency: string;
  status: PaymentStatus;
  createdAt: Date;
  description?: string | null;
  capturedAt?: Date | null;
}

What gets generated

Plain interfaces. One file per table.

Below: TypeScript emitted from a small Postgres schema with an ENUM, a foreign key, and a nullable column. Navigation properties are opt-in — enable the flag and you get typed parent and child references as optional fields (you populate them when you join, leave them out when you don't).

// src/models/order-state.enum.ts
export type OrderState =
  | 'pending'
  | 'paid'
  | 'shipped'
  | 'delivered'
  | 'cancelled';

// src/models/customers.ts
import { Orders } from './orders';

export interface Customers {
  id: string;
  email: string;
  createdAt: Date;
  displayName?: string | null;
  orders?: Array<Orders>;
}

// src/models/orders.ts
import { OrderState } from './order-state.enum';
import { Customers } from './customers';
import { OrderLines } from './order-lines';

export interface Orders {
  id: string;
  customerId: string;
  state: OrderState;
  totalCents: number;
  placedAt: Date;
  notes?: string | null;
  shippedAt?: Date | null;
  customer?: Customers;
  orderLines?: Array<OrderLines>;
}

Three things we get right

Grounded in how the DDL reads.

This generator is types-first: it produces TypeScript interfaces and literal unions, no runtime, no query builder. Each claim here is something you can verify by running the converter on your own schema.

01ProofENUM types become literal unions.Spec · In

Code · Out

schema.sql fragment

CREATE TYPE payment_status AS ENUM (
  'pending', 'authorized', 'captured', 'refunded', 'failed'
);

CREATE TABLE payments (
  status payment_status NOT NULL,
  ...
);

emitted .ts files

// payment-status.enum.ts
export type PaymentStatus =
  | 'pending'
  | 'authorized'
  | 'captured'
  | 'refunded'
  | 'failed';

// payments.ts — the column is typed by the union, not `string`.
import { PaymentStatus } from './payment-status.enum';

export interface Payments {
  status: PaymentStatus;
  // ...
}

Node.js · node-postgres

Types for the queries you already write.

The generator emits interfaces; you write the SQL. Pass the emitted type as the row generic on pool.query and every column lands typed — including Postgres enums as literal unions and nullable columns as optional + nullable.

src/db/payment-repo.ts generated

// src/db/payment-repo.ts
import { Pool } from 'pg';
import { Payments } from '../models/payments';
import { PaymentStatus } from '../models/payment-status.enum';

// Types only — the generator never writes SQL. You do.
// Here: the emitted interface types a hand-written query.
export class PaymentRepo {
  constructor(private readonly pool: Pool) {}

  async findById(id: string): Promise<Payments | null> {
    const { rows } = await this.pool.query<Payments>(
      `SELECT
         id,
         customer_id    AS "customerId",
         amount_cents   AS "amountCents",
         currency,
         status,
         description,
         captured_at    AS "capturedAt",
         created_at     AS "createdAt"
       FROM payments WHERE id = $1`,
      [id],
    );
    return rows[0] ?? null;
  }

  async findByStatus(status: PaymentStatus): Promise<Payments[]> {
    const { rows } = await this.pool.query<Payments>(
      'SELECT ... FROM payments WHERE status = $1',
      [status],
    );
    return rows;
  }
}

Also available via MCP

Or ask Claude to do it.

The same generator ships as a Model Context Protocol server. It calls the same web API this converter uses, so the output is identical. Point Claude Desktop, Cursor, or any MCP-aware agent at a DDL file and it produces the TypeScript interfaces as a diff — free, no token, no leaving the chat.

// claude-desktop config · .mcp.json
{
  "mcpServers": {
    "metaengine": {
      "command": "npx",
      "args": ["-y", "@metaengine/mcp-server"]
    }
  }
}

// Then in Claude:
// "Load db/schema.sql and generate TypeScript
//  models with navigation properties."

See the MCP page

Questions

Things people ask.

This generator is types-only — no runtime, no query builder. The questions below reflect the shape of the output; if yours is not here, run the converter and see.

Plain TypeScript interfaces — one file per table, plus one file per Postgres ENUM type. Columns map to typed fields. That is it: no repository class, no query builder, no runtime dependency.

More converters

Same engine, other stacks.

Every converter runs the same spec-to-IR pipeline. Pick another source format or target stack.

OpenAPI

TypeScript

Angular httpResource, React TanStack Query, or framework-agnostic fetch.

SQL DDL toTypeScript.

Plain interfaces. One file per table.

Grounded in how the DDL reads.

ENUM types become literal unions.

Nullable is explicit and honest.

Types only. No ORM attached.

Types for the queries you already write.

Or ask Claude to do it.

Things people ask.

Same engine, other stacks.

Try it on your own schema.

SQL DDL to
TypeScript.