schematic-pg 0.1.0

package/dist/schema-dsl/parser.js

@@ -0,0 +1,372 @@
+import { TokenType } from './tokens.js';
+export class ParseError extends Error {
+    line;
+    col;
+    expected;
+    found;
+    constructor(expected, found) {
+        super(`Parse error at line ${found.line}, col ${found.col}: expected ${expected}, found ${found.type} (${found.value || 'EOF'})`);
+        this.name = 'ParseError';
+        this.line = found.line;
+        this.col = found.col;
+        this.expected = expected;
+        this.found = found;
+    }
+}
+export class Parser {
+    tokens;
+    index = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parseSchema() {
+        const start = this.current();
+        const extensions = this.parseExtensionsSection();
+        const enums = this.parseEnumsSection();
+        const models = this.parseModelsSection();
+        this.expect(TokenType.EOF, 'end of schema');
+        return {
+            kind: 'Schema',
+            extensions,
+            enums,
+            models,
+            loc: this.loc(start),
+        };
+    }
+    parseModel() {
+        this.expect(TokenType.MODEL, "'model'");
+        const nameToken = this.expect(TokenType.IDENT, 'model name');
+        this.expect(TokenType.LBRACE, "'{'");
+        const model = this.parseModelBody(nameToken.value, nameToken);
+        this.expect(TokenType.RBRACE, "'}'");
+        return model;
+    }
+    parseField() {
+        const start = this.expect(TokenType.IDENT, 'field name');
+        this.expect(TokenType.COLON, "':'");
+        const type = this.parseTypeExpr();
+        const typeLine = type.loc.endLine ?? type.loc.line;
+        const attributes = this.parseFieldAttributes(typeLine);
+        return {
+            kind: 'Field',
+            name: start.value,
+            type,
+            attributes,
+            loc: this.loc(start),
+        };
+    }
+    parseAttribute() {
+        return this.parseAttributeInternal();
+    }
+    parseExtensionsSection() {
+        this.expect(TokenType.EXTENSIONS, "'extensions'");
+        this.expect(TokenType.LBRACE, "'{'");
+        const extensions = [];
+        while (!this.check(TokenType.RBRACE)) {
+            extensions.push(this.parseExtension());
+        }
+        this.expect(TokenType.RBRACE, "'}'");
+        return extensions;
+    }
+    parseExtension() {
+        const start = this.expect(TokenType.IDENT, 'extension name');
+        let options;
+        if (this.check(TokenType.LBRACE)) {
+            options = this.parseBlockLiteral();
+        }
+        return {
+            kind: 'Extension',
+            name: start.value,
+            options,
+            loc: this.loc(start),
+        };
+    }
+    parseEnumsSection() {
+        this.expect(TokenType.ENUMS, "'enums'");
+        this.expect(TokenType.LBRACE, "'{'");
+        const enums = [];
+        while (!this.check(TokenType.RBRACE)) {
+            enums.push(this.parseEnum());
+        }
+        this.expect(TokenType.RBRACE, "'}'");
+        return enums;
+    }
+    parseEnum() {
+        const start = this.expect(TokenType.IDENT, 'enum name');
+        this.expect(TokenType.LBRACE, "'{'");
+        const values = this.parseIdentList();
+        this.expect(TokenType.RBRACE, "'}'");
+        return {
+            kind: 'Enum',
+            name: start.value,
+            values,
+            loc: this.loc(start),
+        };
+    }
+    parseModelsSection() {
+        this.expect(TokenType.MODELS, "'models'");
+        this.expect(TokenType.LBRACE, "'{'");
+        const models = [];
+        while (!this.check(TokenType.RBRACE)) {
+            models.push(this.parseModel());
+        }
+        this.expect(TokenType.RBRACE, "'}'");
+        return models;
+    }
+    parseModelBody(name, start) {
+        const fields = [];
+        const attributes = [];
+        const directives = [];
+        while (!this.check(TokenType.RBRACE)) {
+            if (this.check(TokenType.ATAT)) {
+                directives.push(this.parseDirective());
+                continue;
+            }
+            if (this.check(TokenType.AT)) {
+                attributes.push(this.parseAttributeInternal());
+                continue;
+            }
+            fields.push(this.parseField());
+        }
+        return {
+            kind: 'Model',
+            name,
+            fields,
+            attributes,
+            directives,
+            loc: this.loc(start),
+        };
+    }
+    parseTypeExpr() {
+        const start = this.expect(TokenType.IDENT, 'type name');
+        let args;
+        if (this.check(TokenType.LPAREN)) {
+            this.advance();
+            args = this.parseValueList();
+            this.expect(TokenType.RPAREN, "')'");
+        }
+        let optional = false;
+        let array = false;
+        if (this.check(TokenType.QUESTION)) {
+            this.advance();
+            optional = true;
+        }
+        else if (this.check(TokenType.LBRACKET) && this.peekType(1) === TokenType.RBRACKET) {
+            this.advance();
+            this.advance();
+            array = true;
+        }
+        return {
+            kind: 'TypeExpr',
+            name: start.value,
+            args,
+            optional: optional || undefined,
+            array: array || undefined,
+            loc: this.loc(start),
+        };
+    }
+    parseFieldAttributes(typeLine) {
+        const attributes = [];
+        while (this.check(TokenType.AT) &&
+            this.peekType(1) !== TokenType.AT &&
+            this.current().line === typeLine) {
+            attributes.push(this.parseAttributeInternal());
+        }
+        return attributes;
+    }
+    parseAttributeInternal() {
+        const start = this.expect(TokenType.AT, "'@'");
+        const nameToken = this.expect(TokenType.IDENT, 'attribute name');
+        const args = this.check(TokenType.LPAREN) ? this.parseAttributeArgs() : undefined;
+        return {
+            kind: 'Attribute',
+            name: nameToken.value,
+            args,
+            loc: this.loc(start),
+        };
+    }
+    parseDirective() {
+        const start = this.expect(TokenType.ATAT, "'@@'");
+        const nameToken = this.expect(TokenType.IDENT, 'directive name');
+        let args;
+        if (this.check(TokenType.LBRACE)) {
+            args = {
+                kind: 'KeyValueArgs',
+                pairs: this.parseBlockLiteral().pairs,
+            };
+        }
+        else if (this.check(TokenType.LPAREN)) {
+            args = this.parseAttributeArgs();
+        }
+        return {
+            kind: 'Directive',
+            name: nameToken.value,
+            args,
+            loc: this.loc(start),
+        };
+    }
+    parseAttributeArgs() {
+        this.expect(TokenType.LPAREN, "'('");
+        if (this.check(TokenType.RPAREN)) {
+            this.advance();
+            return { kind: 'ExpressionArgs', expressions: [] };
+        }
+        const args = this.isKeyValueListStart()
+            ? { kind: 'KeyValueArgs', pairs: this.parseKeyValueList() }
+            : { kind: 'ExpressionArgs', expressions: this.parseValueList() };
+        this.expect(TokenType.RPAREN, "')'");
+        return args;
+    }
+    parseValue() {
+        const token = this.current();
+        switch (token.type) {
+            case TokenType.STRING:
+                this.advance();
+                return { kind: 'StringLiteral', value: token.value };
+            case TokenType.TRIPLE_STRING:
+                this.advance();
+                return { kind: 'TripleStringLiteral', value: token.value };
+            case TokenType.NUMBER:
+                this.advance();
+                return { kind: 'NumberLiteral', value: Number(token.value) };
+            case TokenType.BOOLEAN:
+                this.advance();
+                return { kind: 'BooleanLiteral', value: token.value === 'true' };
+            case TokenType.LBRACKET:
+                return this.parseArrayLiteral();
+            case TokenType.LBRACE:
+                return this.parseBlockLiteral();
+            case TokenType.IDENT:
+                return this.parseIdentOrCall();
+            default:
+                throw new ParseError('value', token);
+        }
+    }
+    parseIdentOrCall() {
+        const ident = this.expect(TokenType.IDENT, 'identifier');
+        if (!this.check(TokenType.LPAREN)) {
+            return { kind: 'Identifier', name: ident.value };
+        }
+        this.advance();
+        const args = this.check(TokenType.RPAREN) ? [] : this.parseValueList();
+        this.expect(TokenType.RPAREN, "')'");
+        return {
+            kind: 'CallExpression',
+            callee: ident.value,
+            args,
+        };
+    }
+    parseArrayLiteral() {
+        this.expect(TokenType.LBRACKET, "'['");
+        const elements = this.check(TokenType.RBRACKET) ? [] : this.parseValueList();
+        this.expect(TokenType.RBRACKET, "']'");
+        return { kind: 'ArrayLiteral', elements };
+    }
+    parseBlockLiteral() {
+        this.expect(TokenType.LBRACE, "'{'");
+        const pairs = this.check(TokenType.RBRACE) ? [] : this.parseKeyValueList();
+        this.expect(TokenType.RBRACE, "'}'");
+        return { kind: 'BlockLiteral', pairs };
+    }
+    parseKeyValueList() {
+        const pairs = [];
+        do {
+            const keyToken = this.expect(TokenType.IDENT, 'key');
+            this.expect(TokenType.COLON, "':'");
+            const value = this.parseValue();
+            pairs.push({
+                key: keyToken.value,
+                value,
+                loc: this.loc(keyToken),
+            });
+        } while (this.match(TokenType.COMMA) && !this.isListEnd());
+        this.consumeTrailingComma();
+        return pairs;
+    }
+    parseValueList() {
+        const values = [];
+        do {
+            values.push(this.parseValue());
+        } while (this.match(TokenType.COMMA) && !this.isListEnd());
+        this.consumeTrailingComma();
+        return values;
+    }
+    parseIdentList() {
+        const values = [];
+        do {
+            values.push(this.expect(TokenType.IDENT, 'identifier').value);
+        } while (this.match(TokenType.COMMA) && !this.check(TokenType.RBRACE));
+        this.consumeTrailingComma();
+        return values;
+    }
+    isKeyValueListStart() {
+        if (!this.check(TokenType.IDENT)) {
+            return false;
+        }
+        return this.peekType(1) === TokenType.COLON;
+    }
+    isListEnd() {
+        return (this.check(TokenType.RPAREN) ||
+            this.check(TokenType.RBRACE) ||
+            this.check(TokenType.RBRACKET));
+    }
+    consumeTrailingComma() {
+        if (this.isListEnd() && this.previous().type === TokenType.COMMA) {
+            // Trailing comma already consumed by match(); nothing else to do.
+        }
+    }
+    loc(start) {
+        const prev = this.previous();
+        return {
+            line: start.line,
+            col: start.col,
+            endLine: prev.line,
+            endCol: prev.col + prev.value.length,
+        };
+    }
+    current() {
+        return this.tokens[this.index] ?? this.eofToken();
+    }
+    previous() {
+        return this.tokens[this.index - 1] ?? this.eofToken();
+    }
+    advance() {
+        if (!this.isAtEnd()) {
+            this.index += 1;
+        }
+        return this.previous();
+    }
+    match(type) {
+        if (!this.check(type)) {
+            return false;
+        }
+        this.advance();
+        return true;
+    }
+    check(type) {
+        return this.current().type === type;
+    }
+    peekType(offset) {
+        return this.tokens[this.index + offset]?.type ?? TokenType.EOF;
+    }
+    expect(type, description) {
+        const token = this.current();
+        if (token.type !== type) {
+            throw new ParseError(description, token);
+        }
+        this.advance();
+        return token;
+    }
+    isAtEnd() {
+        return this.current().type === TokenType.EOF;
+    }
+    eofToken() {
+        const last = this.tokens[this.tokens.length - 1];
+        return {
+            type: TokenType.EOF,
+            value: '',
+            line: last?.line ?? 1,
+            col: last?.col ?? 1,
+        };
+    }
+}

package/dist/schema-dsl/tokens.d.ts

@@ -0,0 +1,30 @@
+export declare enum TokenType {
+    EXTENSIONS = "EXTENSIONS",
+    ENUMS = "ENUMS",
+    MODELS = "MODELS",
+    MODEL = "MODEL",
+    STRING = "STRING",
+    TRIPLE_STRING = "TRIPLE_STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    IDENT = "IDENT",
+    LBRACE = "LBRACE",
+    RBRACE = "RBRACE",
+    LBRACKET = "LBRACKET",
+    RBRACKET = "RBRACKET",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    COLON = "COLON",
+    COMMA = "COMMA",
+    QUESTION = "QUESTION",
+    AT = "AT",
+    ATAT = "ATAT",
+    EOF = "EOF"
+}
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    col: number;
+}
+export declare function keywordTokenType(value: string): TokenType;

package/dist/schema-dsl/tokens.js

@@ -0,0 +1,35 @@
+export var TokenType;
+(function (TokenType) {
+    TokenType["EXTENSIONS"] = "EXTENSIONS";
+    TokenType["ENUMS"] = "ENUMS";
+    TokenType["MODELS"] = "MODELS";
+    TokenType["MODEL"] = "MODEL";
+    TokenType["STRING"] = "STRING";
+    TokenType["TRIPLE_STRING"] = "TRIPLE_STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["IDENT"] = "IDENT";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["LBRACKET"] = "LBRACKET";
+    TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["COLON"] = "COLON";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["AT"] = "AT";
+    TokenType["ATAT"] = "ATAT";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+const KEYWORDS = {
+    extensions: TokenType.EXTENSIONS,
+    enums: TokenType.ENUMS,
+    models: TokenType.MODELS,
+    model: TokenType.MODEL,
+    true: TokenType.BOOLEAN,
+    false: TokenType.BOOLEAN,
+};
+export function keywordTokenType(value) {
+    return KEYWORDS[value] ?? TokenType.IDENT;
+}

package/dist/sql-generator/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sql-generator/cli.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SqlGenerator } from './sql-generator.js';
+const schemaPath = process.argv[2] ?? join(process.cwd(), 'app.schema');
+const source = readFileSync(schemaPath, 'utf8');
+const sql = new SqlGenerator().generateFromSource(source);
+process.stdout.write(sql);

package/dist/sql-generator/generators/drop-tables.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../../schema-dsl/ast.js';
+export declare function generateDropTables(schema: Schema): string;

package/dist/sql-generator/generators/drop-tables.js

@@ -0,0 +1,8 @@
+import { joinSection } from '../utils/format.js';
+import { quoteIdentifier, toTableName } from '../utils/snake-case.js';
+export function generateDropTables(schema) {
+    const statements = [...schema.models]
+        .reverse()
+        .map((model) => `DROP TABLE IF EXISTS ${quoteIdentifier(toTableName(model.name))} CASCADE;`);
+    return joinSection('Drop tables', statements);
+}

package/dist/sql-generator/generators/enums.d.ts

@@ -0,0 +1,4 @@
+import type { Enum, Schema } from '../../schema-dsl/ast.js';
+export declare function generateEnum(enumDef: Enum): string;
+export declare function generateAddEnumValue(enumName: string, value: string): string;
+export declare function generateEnums(schema: Schema): string;

package/dist/sql-generator/generators/enums.js

@@ -0,0 +1,16 @@
+import { joinSection } from '../utils/format.js';
+import { escapeSqlString } from '../utils/value-formatter.js';
+import { toSnakeCase } from '../utils/snake-case.js';
+export function generateEnum(enumDef) {
+    const typeName = toSnakeCase(enumDef.name);
+    const values = enumDef.values.map((value) => `'${escapeSqlString(value)}'`).join(', ');
+    return `CREATE TYPE ${typeName} AS ENUM (${values});`;
+}
+export function generateAddEnumValue(enumName, value) {
+    const typeName = toSnakeCase(enumName);
+    return `ALTER TYPE ${typeName} ADD VALUE '${escapeSqlString(value)}';`;
+}
+export function generateEnums(schema) {
+    const statements = schema.enums.map((enumDef) => generateEnum(enumDef));
+    return joinSection('Enums', statements);
+}

package/dist/sql-generator/generators/extensions.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from '../../schema-dsl/ast.js';
+export declare function generateCreateExtension(name: string): string;
+export declare function generateDropExtension(name: string): string;
+export declare function generateExtensions(schema: Schema): string;

package/dist/sql-generator/generators/extensions.js

@@ -0,0 +1,11 @@
+import { joinSection } from '../utils/format.js';
+export function generateCreateExtension(name) {
+    return `CREATE EXTENSION IF NOT EXISTS "${name}" WITH SCHEMA public;`;
+}
+export function generateDropExtension(name) {
+    return `DROP EXTENSION IF EXISTS "${name}";`;
+}
+export function generateExtensions(schema) {
+    const statements = schema.extensions.map((extension) => generateCreateExtension(extension.name));
+    return joinSection('Extensions', statements);
+}

package/dist/sql-generator/generators/foreign-keys.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from '../../schema-dsl/ast.js';
+import { type ForeignKeyInfo } from '../utils/ast-helpers.js';
+export declare function generateForeignKey(foreignKey: ForeignKeyInfo): string;
+export declare function generateForeignKeys(schema: Schema): string;

package/dist/sql-generator/generators/foreign-keys.js

@@ -0,0 +1,23 @@
+import { collectForeignKeys } from '../utils/ast-helpers.js';
+import { joinSection } from '../utils/format.js';
+import { quoteIdentifier } from '../utils/snake-case.js';
+export function generateForeignKey(foreignKey) {
+    const constraintName = `${foreignKey.sourceTable}_${foreignKey.sourceColumns.join('_')}_fkey`;
+    const sourceColumns = foreignKey.sourceColumns.join(', ');
+    const targetColumns = foreignKey.targetColumns.join(', ');
+    const lines = [
+        `ALTER TABLE ${quoteIdentifier(foreignKey.sourceTable)} ADD CONSTRAINT ${constraintName}`,
+        `  FOREIGN KEY (${sourceColumns}) REFERENCES ${quoteIdentifier(foreignKey.targetTable)} (${targetColumns})`,
+    ];
+    if (foreignKey.onDelete) {
+        lines.push(`  ON DELETE ${foreignKey.onDelete}`);
+    }
+    if (foreignKey.onUpdate) {
+        lines.push(`  ON UPDATE ${foreignKey.onUpdate}`);
+    }
+    return lines.join('\n') + ';';
+}
+export function generateForeignKeys(schema) {
+    const statements = collectForeignKeys(schema).map((foreignKey) => generateForeignKey(foreignKey));
+    return joinSection('Alter tables (foreign keys)', statements);
+}

package/dist/sql-generator/generators/indexes.d.ts

@@ -0,0 +1,13 @@
+import type { Model, Schema } from '../../schema-dsl/ast.js';
+export interface NormalizedIndex {
+    fields: string[];
+    where?: string;
+    unique?: boolean;
+    name?: string;
+    type?: string;
+}
+export declare function buildIndexName(tableName: string, fields: string[]): string;
+export declare function resolveIndexName(tableName: string, normalized: NormalizedIndex): string;
+export declare function generateCreateIndex(model: Model, normalized: NormalizedIndex): string;
+export declare function generateDropIndex(model: Model, normalized: NormalizedIndex): string;
+export declare function generateIndexes(schema: Schema): string;

package/dist/sql-generator/generators/indexes.js

@@ -0,0 +1,39 @@
+import { getDirectives, getModelNames, normalizeIndexDirective, } from '../utils/ast-helpers.js';
+import { joinSection } from '../utils/format.js';
+import { quoteIdentifier, toSnakeCase, toTableName } from '../utils/snake-case.js';
+export function buildIndexName(tableName, fields) {
+    const fieldPart = fields.map(toSnakeCase).join('_');
+    return `${tableName}_${fieldPart}_idx`;
+}
+export function resolveIndexName(tableName, normalized) {
+    return normalized.name ?? buildIndexName(tableName, normalized.fields);
+}
+export function generateCreateIndex(model, normalized) {
+    const tableName = quoteIdentifier(toTableName(model.name));
+    const columns = normalized.fields.map(toSnakeCase).join(', ');
+    const indexName = resolveIndexName(toTableName(model.name), normalized);
+    const uniqueKeyword = normalized.unique ? 'UNIQUE ' : '';
+    const usingClause = normalized.type && normalized.type.toUpperCase() !== 'BTREE'
+        ? ` USING ${normalized.type.toLowerCase()}`
+        : normalized.type?.toUpperCase() === 'BTREE'
+            ? ' USING btree'
+            : '';
+    const whereClause = normalized.where ? ` WHERE ${normalized.where}` : '';
+    return `CREATE ${uniqueKeyword}INDEX ${indexName} ON ${tableName}${usingClause} (${columns})${whereClause};`;
+}
+export function generateDropIndex(model, normalized) {
+    const indexName = resolveIndexName(toTableName(model.name), normalized);
+    return `DROP INDEX IF EXISTS ${indexName};`;
+}
+export function generateIndexes(schema) {
+    const modelNames = getModelNames(schema);
+    const statements = [];
+    for (const model of schema.models) {
+        const indexDirectives = getDirectives(model, 'index');
+        for (const directive of indexDirectives) {
+            const normalized = normalizeIndexDirective(directive, model, modelNames);
+            statements.push(generateCreateIndex(model, normalized));
+        }
+    }
+    return joinSection('Create indexes', statements);
+}

package/dist/sql-generator/generators/tables.d.ts

@@ -0,0 +1,4 @@
+import type { Field, Model, Schema } from '../../schema-dsl/ast.js';
+export declare function generateTables(schema: Schema): string;
+export declare function generateTable(model: Model, enumNames: Set<string>, modelNames: Set<string>): string;
+export declare function generateColumnDefinition(field: Field, model: Model, enumNames: Set<string>, modelNames: Set<string>): string;

package/dist/sql-generator/generators/tables.js

@@ -0,0 +1,65 @@
+import { collectValidationComments, getDefaultExpression, getEnumNames, getModelNames, getPrimaryKey, getStoredFields, fieldHasAttribute, } from '../utils/ast-helpers.js';
+import { formatCreateTable, joinSection } from '../utils/format.js';
+import { mapColumnType } from '../utils/type-mapper.js';
+import { quoteIdentifier, toSnakeCase, toTableName } from '../utils/snake-case.js';
+export function generateTables(schema) {
+    const enumNames = getEnumNames(schema);
+    const modelNames = getModelNames(schema);
+    const statements = schema.models.map((model) => generateTable(model, enumNames, modelNames));
+    return joinSection('Create tables', statements);
+}
+export function generateTable(model, enumNames, modelNames) {
+    const primaryKey = getPrimaryKey(model);
+    const blocks = [];
+    for (const field of getStoredFields(model, modelNames)) {
+        const columnParts = [];
+        const columnName = toSnakeCase(field.name);
+        columnParts.push(columnName);
+        columnParts.push(mapColumnType(field.type, enumNames));
+        const isSingleFieldPrimaryKey = primaryKey && !primaryKey.composite && primaryKey.fields.length === 1 && primaryKey.fields[0] === field.name;
+        if (isSingleFieldPrimaryKey) {
+            columnParts.push('PRIMARY KEY');
+        }
+        if (fieldHasAttribute(field, 'unique')) {
+            columnParts.push('UNIQUE');
+        }
+        const defaultExpression = getDefaultExpression(field, enumNames);
+        if (defaultExpression) {
+            columnParts.push(`DEFAULT ${defaultExpression}`);
+        }
+        if (!field.type.optional) {
+            columnParts.push('NOT NULL');
+        }
+        const block = [columnParts.join(' ')];
+        block.push(...collectValidationComments(field));
+        blocks.push(block);
+    }
+    if (primaryKey?.composite) {
+        const pkColumns = primaryKey.fields.map(toSnakeCase).join(', ');
+        blocks.push([`PRIMARY KEY (${pkColumns})`]);
+    }
+    const tableName = quoteIdentifier(toTableName(model.name));
+    return formatCreateTable(tableName, blocks);
+}
+export function generateColumnDefinition(field, model, enumNames, modelNames) {
+    const primaryKey = getPrimaryKey(model);
+    const columnParts = [];
+    const columnName = toSnakeCase(field.name);
+    columnParts.push(columnName);
+    columnParts.push(mapColumnType(field.type, enumNames));
+    const isSingleFieldPrimaryKey = primaryKey && !primaryKey.composite && primaryKey.fields.length === 1 && primaryKey.fields[0] === field.name;
+    if (isSingleFieldPrimaryKey) {
+        columnParts.push('PRIMARY KEY');
+    }
+    if (fieldHasAttribute(field, 'unique')) {
+        columnParts.push('UNIQUE');
+    }
+    const defaultExpression = getDefaultExpression(field, enumNames);
+    if (defaultExpression) {
+        columnParts.push(`DEFAULT ${defaultExpression}`);
+    }
+    if (!field.type.optional) {
+        columnParts.push('NOT NULL');
+    }
+    return columnParts.join(' ');
+}

package/dist/sql-generator/generators/triggers.d.ts

@@ -0,0 +1,6 @@
+import type { Model, Schema } from '../../schema-dsl/ast.js';
+import { type NormalizedTrigger } from '../utils/ast-helpers.js';
+export type { NormalizedTrigger };
+export declare function generateCreateTrigger(model: Model, normalized: NormalizedTrigger): string;
+export declare function generateDropTrigger(model: Model, normalized: NormalizedTrigger): string;
+export declare function generateTriggers(schema: Schema): string;