schematic-pg 0.1.0

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

@@ -0,0 +1,47 @@
+import { getDirectives, normalizeTriggerDirective, resolveTriggerNames, } from '../utils/ast-helpers.js';
+import { joinSection } from '../utils/format.js';
+import { quoteIdentifier, toTableName } from '../utils/snake-case.js';
+export function generateCreateTrigger(model, normalized) {
+    const tableName = quoteIdentifier(toTableName(model.name));
+    const { functionName, triggerName } = resolveTriggerNames(model, normalized.timing, normalized.event);
+    const forEachClause = normalized.level === 'STATEMENT' ? 'FOR EACH STATEMENT' : 'FOR EACH ROW';
+    const functionStatement = [
+        `CREATE OR REPLACE FUNCTION ${functionName}()`,
+        'RETURNS TRIGGER AS $$',
+        'BEGIN',
+        indentTriggerBody(normalized.execute),
+        'END;',
+        '$$ LANGUAGE plpgsql;',
+    ].join('\n');
+    const triggerStatement = [
+        `CREATE TRIGGER ${triggerName}`,
+        `  ${normalized.timing} ${normalized.event} ON ${tableName}`,
+        `  ${forEachClause}`,
+        `  EXECUTE FUNCTION ${functionName}();`,
+    ].join('\n');
+    return `${functionStatement}\n\n${triggerStatement}`;
+}
+export function generateDropTrigger(model, normalized) {
+    const tableName = quoteIdentifier(toTableName(model.name));
+    const { functionName, triggerName } = resolveTriggerNames(model, normalized.timing, normalized.event);
+    return [
+        `DROP TRIGGER IF EXISTS ${triggerName} ON ${tableName};`,
+        `DROP FUNCTION IF EXISTS ${functionName}();`,
+    ].join('\n');
+}
+export function generateTriggers(schema) {
+    const statements = [];
+    for (const model of schema.models) {
+        for (const directive of getDirectives(model, 'trigger')) {
+            const normalized = normalizeTriggerDirective(directive);
+            statements.push(generateCreateTrigger(model, normalized));
+        }
+    }
+    return joinSection('Create triggers', statements);
+}
+function indentTriggerBody(body) {
+    return body
+        .split('\n')
+        .map((line) => (line.length > 0 ? `  ${line}` : line))
+        .join('\n');
+}

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

@@ -0,0 +1,5 @@
+export { SqlGenerator, toSnakeCase, toTableName } from './sql-generator.js';
+export { MigrationPlanner, getStoredFieldNames } from './migration-planner.js';
+export { MigrationSqlGenerator } from './migration-sql-generator.js';
+export type { Migration } from './migration-types.js';
+export type { Schema } from '../schema-dsl/ast.js';

package/dist/sql-generator/index.js

@@ -0,0 +1,3 @@
+export { SqlGenerator, toSnakeCase, toTableName } from './sql-generator.js';
+export { MigrationPlanner, getStoredFieldNames } from './migration-planner.js';
+export { MigrationSqlGenerator } from './migration-sql-generator.js';

package/dist/sql-generator/migration-planner.d.ts

@@ -0,0 +1,15 @@
+import type { Model, Schema } from '../schema-dsl/ast.js';
+import type { Migration } from './migration-types.js';
+export declare class MigrationPlanner {
+    generateMigration(oldSchema: Schema, newSchema: Schema): Migration[];
+    private diffExtensions;
+    private diffEnums;
+    private diffModels;
+    private diffField;
+    private diffConstraints;
+    private diffIndexes;
+    private diffTriggers;
+    private triggerSignatures;
+    private indexSignatures;
+}
+export declare function getStoredFieldNames(model: Model, modelNames: Set<string>): string[];

package/dist/sql-generator/migration-planner.js

@@ -0,0 +1,207 @@
+import { collectForeignKeys, getDirectives, getEnumNames, getModelNames, getStoredFields, isStoredField, normalizeIndexDirective, normalizeTriggerDirective, serializeColumnType, serializeDefault, serializeForeignKey, } from './utils/ast-helpers.js';
+export class MigrationPlanner {
+    generateMigration(oldSchema, newSchema) {
+        const migrations = [];
+        migrations.push(...this.diffExtensions(oldSchema, newSchema));
+        migrations.push(...this.diffEnums(oldSchema, newSchema));
+        migrations.push(...this.diffModels(oldSchema, newSchema));
+        migrations.push(...this.diffConstraints(oldSchema, newSchema));
+        migrations.push(...this.diffIndexes(oldSchema, newSchema));
+        migrations.push(...this.diffTriggers(oldSchema, newSchema));
+        return migrations;
+    }
+    diffExtensions(oldSchema, newSchema) {
+        const migrations = [];
+        const oldNames = new Set(oldSchema.extensions.map((extension) => extension.name));
+        const newNames = new Set(newSchema.extensions.map((extension) => extension.name));
+        for (const name of newNames) {
+            if (!oldNames.has(name)) {
+                migrations.push({ kind: 'CreateExtension', extensionName: name });
+            }
+        }
+        for (const name of oldNames) {
+            if (!newNames.has(name)) {
+                migrations.push({ kind: 'DropExtension', extensionName: name });
+            }
+        }
+        return migrations;
+    }
+    diffEnums(oldSchema, newSchema) {
+        const migrations = [];
+        const oldEnums = new Map(oldSchema.enums.map((enumDef) => [enumDef.name, enumDef]));
+        const newEnums = new Map(newSchema.enums.map((enumDef) => [enumDef.name, enumDef]));
+        for (const [enumName, enumDef] of newEnums) {
+            if (!oldEnums.has(enumName)) {
+                migrations.push({ kind: 'CreateEnum', enumName });
+                continue;
+            }
+            const oldValues = oldEnums.get(enumName).values;
+            for (const value of enumDef.values) {
+                if (!oldValues.includes(value)) {
+                    migrations.push({ kind: 'AddEnumValue', enumName, value });
+                }
+            }
+        }
+        return migrations;
+    }
+    diffModels(oldSchema, newSchema) {
+        const migrations = [];
+        const oldModels = new Map(oldSchema.models.map((model) => [model.name, model]));
+        const newModels = new Map(newSchema.models.map((model) => [model.name, model]));
+        const oldModelNames = getModelNames(oldSchema);
+        const newModelNames = getModelNames(newSchema);
+        const oldEnumNames = getEnumNames(oldSchema);
+        const newEnumNames = getEnumNames(newSchema);
+        for (const [modelName] of newModels) {
+            if (!oldModels.has(modelName)) {
+                migrations.push({ kind: 'CreateTable', modelName });
+            }
+        }
+        for (const [modelName] of oldModels) {
+            if (!newModels.has(modelName)) {
+                migrations.push({ kind: 'DropTable', modelName });
+            }
+        }
+        for (const [modelName, newModel] of newModels) {
+            const oldModel = oldModels.get(modelName);
+            if (!oldModel) {
+                continue;
+            }
+            const oldFields = new Map(getStoredFields(oldModel, oldModelNames).map((field) => [field.name, field]));
+            const newFields = new Map(getStoredFields(newModel, newModelNames).map((field) => [field.name, field]));
+            for (const [fieldName] of newFields) {
+                if (!oldFields.has(fieldName)) {
+                    migrations.push({ kind: 'AddColumn', modelName, fieldName });
+                }
+            }
+            for (const [fieldName] of oldFields) {
+                if (!newFields.has(fieldName)) {
+                    migrations.push({ kind: 'DropColumn', modelName, fieldName });
+                }
+            }
+            for (const [fieldName, newField] of newFields) {
+                const oldField = oldFields.get(fieldName);
+                if (!oldField) {
+                    continue;
+                }
+                migrations.push(...this.diffField(modelName, oldField, newField, oldEnumNames, newEnumNames));
+            }
+        }
+        return migrations;
+    }
+    diffField(modelName, oldField, newField, oldEnumNames, newEnumNames) {
+        const migrations = [];
+        const oldType = serializeColumnType(oldField.type, oldEnumNames);
+        const newType = serializeColumnType(newField.type, newEnumNames);
+        if (oldType !== newType) {
+            migrations.push({
+                kind: 'AlterColumn',
+                modelName,
+                fieldName: oldField.name,
+                change: { type: 'type', from: oldType, to: newType },
+            });
+        }
+        const oldOptional = Boolean(oldField.type.optional);
+        const newOptional = Boolean(newField.type.optional);
+        if (oldOptional !== newOptional) {
+            migrations.push({
+                kind: 'AlterColumn',
+                modelName,
+                fieldName: oldField.name,
+                change: { type: 'nullability', from: oldOptional, to: newOptional },
+            });
+        }
+        const oldDefault = serializeDefault(oldField, oldEnumNames);
+        const newDefault = serializeDefault(newField, newEnumNames);
+        if (oldDefault !== newDefault) {
+            migrations.push({
+                kind: 'AlterColumn',
+                modelName,
+                fieldName: oldField.name,
+                change: { type: 'default', from: oldDefault, to: newDefault },
+            });
+        }
+        return migrations;
+    }
+    diffConstraints(oldSchema, newSchema) {
+        const migrations = [];
+        const oldKeys = new Map(collectForeignKeys(oldSchema).map((foreignKey) => [serializeForeignKey(foreignKey), foreignKey]));
+        const newKeys = new Map(collectForeignKeys(newSchema).map((foreignKey) => [serializeForeignKey(foreignKey), foreignKey]));
+        for (const [signature, foreignKey] of newKeys) {
+            if (!oldKeys.has(signature)) {
+                migrations.push({
+                    kind: 'AddConstraint',
+                    modelName: foreignKey.sourceModel,
+                    constraintType: 'foreignKey',
+                    details: signature,
+                });
+            }
+        }
+        for (const [signature, foreignKey] of oldKeys) {
+            if (!newKeys.has(signature)) {
+                migrations.push({
+                    kind: 'DropConstraint',
+                    modelName: foreignKey.sourceModel,
+                    constraintType: 'foreignKey',
+                    details: signature,
+                });
+            }
+        }
+        return migrations;
+    }
+    diffIndexes(oldSchema, newSchema) {
+        const migrations = [];
+        const oldModels = new Map(oldSchema.models.map((model) => [model.name, model]));
+        const newModels = new Map(newSchema.models.map((model) => [model.name, model]));
+        const oldModelNames = getModelNames(oldSchema);
+        const newModelNames = getModelNames(newSchema);
+        for (const [modelName, newModel] of newModels) {
+            const oldModel = oldModels.get(modelName);
+            const oldIndexes = oldModel
+                ? this.indexSignatures(oldModel, oldModelNames)
+                : new Set();
+            const newIndexes = this.indexSignatures(newModel, newModelNames);
+            for (const signature of newIndexes) {
+                if (!oldIndexes.has(signature)) {
+                    migrations.push({ kind: 'CreateIndex', modelName, signature });
+                }
+            }
+            for (const signature of oldIndexes) {
+                if (!newIndexes.has(signature)) {
+                    migrations.push({ kind: 'DropIndex', modelName, signature });
+                }
+            }
+        }
+        return migrations;
+    }
+    diffTriggers(oldSchema, newSchema) {
+        const migrations = [];
+        const oldModels = new Map(oldSchema.models.map((model) => [model.name, model]));
+        const newModels = new Map(newSchema.models.map((model) => [model.name, model]));
+        for (const [modelName, newModel] of newModels) {
+            const oldModel = oldModels.get(modelName);
+            const oldTriggers = oldModel ? this.triggerSignatures(oldModel) : new Set();
+            const newTriggers = this.triggerSignatures(newModel);
+            for (const signature of newTriggers) {
+                if (!oldTriggers.has(signature)) {
+                    migrations.push({ kind: 'CreateTrigger', modelName, signature });
+                }
+            }
+            for (const signature of oldTriggers) {
+                if (!newTriggers.has(signature)) {
+                    migrations.push({ kind: 'DropTrigger', modelName, signature });
+                }
+            }
+        }
+        return migrations;
+    }
+    triggerSignatures(model) {
+        return new Set(getDirectives(model, 'trigger').map((directive) => JSON.stringify(normalizeTriggerDirective(directive))));
+    }
+    indexSignatures(model, modelNames) {
+        return new Set(getDirectives(model, 'index').map((directive) => JSON.stringify(normalizeIndexDirective(directive, model, modelNames))));
+    }
+}
+export function getStoredFieldNames(model, modelNames) {
+    return model.fields.filter((field) => isStoredField(field, modelNames)).map((field) => field.name);
+}

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

@@ -0,0 +1,9 @@
+import type { Schema } from '../schema-dsl/ast.js';
+import type { Migration } from './migration-types.js';
+export declare class MigrationSqlGenerator {
+    generate(migrations: Migration[], newSchema: Schema): string;
+    private migrationToSql;
+    private getField;
+    private findIndexBySignature;
+    private findTriggerBySignature;
+}

package/dist/sql-generator/migration-sql-generator.js

@@ -0,0 +1,181 @@
+import { generateAddEnumValue, generateEnum } from './generators/enums.js';
+import { generateCreateExtension, generateDropExtension } from './generators/extensions.js';
+import { generateForeignKey } from './generators/foreign-keys.js';
+import { generateCreateIndex, generateDropIndex, } from './generators/indexes.js';
+import { generateColumnDefinition, generateTable } from './generators/tables.js';
+import { generateCreateTrigger, generateDropTrigger, } from './generators/triggers.js';
+import { getDirectives, getDefaultExpression, getEnumNames, getModelNames, getStoredFields, normalizeIndexDirective, normalizeTriggerDirective, parseForeignKeySignature, } from './utils/ast-helpers.js';
+import { quoteIdentifier, toSnakeCase, toTableName } from './utils/snake-case.js';
+const MIGRATION_ORDER = {
+    CreateExtension: 0,
+    CreateEnum: 1,
+    AddEnumValue: 2,
+    CreateTable: 3,
+    AddColumn: 4,
+    AlterColumn: 5,
+    AddConstraint: 6,
+    DropColumn: 7,
+    DropConstraint: 8,
+    DropIndex: 9,
+    CreateIndex: 10,
+    CreateTrigger: 11,
+    DropTrigger: 12,
+    DropTable: 13,
+    DropExtension: 14,
+};
+export class MigrationSqlGenerator {
+    generate(migrations, newSchema) {
+        if (migrations.length === 0) {
+            return '';
+        }
+        const enumNames = getEnumNames(newSchema);
+        const modelNames = getModelNames(newSchema);
+        const modelMap = new Map(newSchema.models.map((model) => [model.name, model]));
+        const enumMap = new Map(newSchema.enums.map((enumDef) => [enumDef.name, enumDef]));
+        const ordered = [...migrations].sort((left, right) => MIGRATION_ORDER[left.kind] - MIGRATION_ORDER[right.kind]);
+        const statements = ordered.map((migration) => this.migrationToSql(migration, { newSchema, enumNames, modelNames, modelMap, enumMap }));
+        return `${statements.join('\n\n')}\n`;
+    }
+    migrationToSql(migration, context) {
+        const { enumNames, modelNames, modelMap, enumMap } = context;
+        switch (migration.kind) {
+            case 'CreateExtension':
+                return generateCreateExtension(migration.extensionName);
+            case 'DropExtension':
+                return generateDropExtension(migration.extensionName);
+            case 'CreateEnum': {
+                const enumDef = enumMap.get(migration.enumName);
+                if (!enumDef) {
+                    throw new Error(`Enum "${migration.enumName}" not found in new schema`);
+                }
+                return generateEnum(enumDef);
+            }
+            case 'AddEnumValue':
+                return generateAddEnumValue(migration.enumName, migration.value);
+            case 'CreateTable': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                return generateTable(model, enumNames, modelNames);
+            }
+            case 'AddColumn': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                const field = this.getField(model, migration.fieldName, modelNames);
+                const columnDef = generateColumnDefinition(field, model, enumNames, modelNames);
+                const tableName = quoteIdentifier(toTableName(model.name));
+                return `ALTER TABLE ${tableName} ADD COLUMN ${columnDef};`;
+            }
+            case 'DropColumn': {
+                const tableName = quoteIdentifier(toTableName(migration.modelName));
+                const columnName = toSnakeCase(migration.fieldName);
+                return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+            }
+            case 'AlterColumn': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                const field = this.getField(model, migration.fieldName, modelNames);
+                const tableName = quoteIdentifier(toTableName(model.name));
+                const columnName = toSnakeCase(migration.fieldName);
+                switch (migration.change.type) {
+                    case 'type':
+                        return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${migration.change.to} USING ${columnName}::${migration.change.to};`;
+                    case 'nullability':
+                        return migration.change.to
+                            ? `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL;`
+                            : `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL;`;
+                    case 'default': {
+                        const defaultExpression = getDefaultExpression(field, enumNames);
+                        return defaultExpression
+                            ? `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${defaultExpression};`
+                            : `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT;`;
+                    }
+                }
+            }
+            case 'DropTable': {
+                const tableName = quoteIdentifier(toTableName(migration.modelName));
+                return `DROP TABLE IF EXISTS ${tableName} CASCADE;`;
+            }
+            case 'CreateIndex': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                const normalized = this.findIndexBySignature(model, migration.signature, modelNames);
+                return generateCreateIndex(model, normalized);
+            }
+            case 'DropIndex': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                const normalized = JSON.parse(migration.signature);
+                return generateDropIndex(model, normalized);
+            }
+            case 'AddConstraint': {
+                if (migration.constraintType !== 'foreignKey') {
+                    throw new Error(`Unsupported constraint type: ${migration.constraintType}`);
+                }
+                return generateForeignKey(parseForeignKeySignature(migration.details));
+            }
+            case 'DropConstraint': {
+                if (migration.constraintType !== 'foreignKey') {
+                    throw new Error(`Unsupported constraint type: ${migration.constraintType}`);
+                }
+                const foreignKey = parseForeignKeySignature(migration.details);
+                const constraintName = `${foreignKey.sourceTable}_${foreignKey.sourceColumns.join('_')}_fkey`;
+                return `ALTER TABLE ${quoteIdentifier(foreignKey.sourceTable)} DROP CONSTRAINT ${constraintName};`;
+            }
+            case 'CreateTrigger': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                const normalized = this.findTriggerBySignature(model, migration.signature);
+                return generateCreateTrigger(model, normalized);
+            }
+            case 'DropTrigger': {
+                const model = modelMap.get(migration.modelName);
+                if (!model) {
+                    throw new Error(`Model "${migration.modelName}" not found in new schema`);
+                }
+                const normalized = JSON.parse(migration.signature);
+                return generateDropTrigger(model, normalized);
+            }
+            default: {
+                const exhaustive = migration;
+                throw new Error(`Unsupported migration kind: ${exhaustive.kind}`);
+            }
+        }
+    }
+    getField(model, fieldName, modelNames) {
+        const field = getStoredFields(model, modelNames).find((item) => item.name === fieldName);
+        if (!field) {
+            throw new Error(`Field "${fieldName}" not found on model "${model.name}"`);
+        }
+        return field;
+    }
+    findIndexBySignature(model, signature, modelNames) {
+        for (const directive of getDirectives(model, 'index')) {
+            const normalized = normalizeIndexDirective(directive, model, modelNames);
+            if (JSON.stringify(normalized) === signature) {
+                return normalized;
+            }
+        }
+        throw new Error(`Index signature not found on model "${model.name}"`);
+    }
+    findTriggerBySignature(model, signature) {
+        for (const directive of getDirectives(model, 'trigger')) {
+            const normalized = normalizeTriggerDirective(directive);
+            if (JSON.stringify(normalized) === signature) {
+                return normalized;
+            }
+        }
+        throw new Error(`Trigger signature not found on model "${model.name}"`);
+    }
+}

package/dist/sql-generator/migration-types.d.ts

@@ -0,0 +1,86 @@
+export type Migration = CreateExtension | DropExtension | CreateTable | DropTable | AddColumn | DropColumn | AlterColumn | CreateIndex | DropIndex | CreateEnum | AddEnumValue | AddConstraint | DropConstraint | CreateTrigger | DropTrigger;
+export interface CreateTable {
+    kind: 'CreateTable';
+    modelName: string;
+}
+export interface DropTable {
+    kind: 'DropTable';
+    modelName: string;
+}
+export interface AddColumn {
+    kind: 'AddColumn';
+    modelName: string;
+    fieldName: string;
+}
+export interface DropColumn {
+    kind: 'DropColumn';
+    modelName: string;
+    fieldName: string;
+}
+export interface AlterColumn {
+    kind: 'AlterColumn';
+    modelName: string;
+    fieldName: string;
+    change: {
+        type: 'type';
+        from: string;
+        to: string;
+    } | {
+        type: 'nullability';
+        from: boolean;
+        to: boolean;
+    } | {
+        type: 'default';
+        from?: string;
+        to?: string;
+    };
+}
+export interface CreateIndex {
+    kind: 'CreateIndex';
+    modelName: string;
+    signature: string;
+}
+export interface DropIndex {
+    kind: 'DropIndex';
+    modelName: string;
+    signature: string;
+}
+export interface CreateEnum {
+    kind: 'CreateEnum';
+    enumName: string;
+}
+export interface AddEnumValue {
+    kind: 'AddEnumValue';
+    enumName: string;
+    value: string;
+}
+export interface AddConstraint {
+    kind: 'AddConstraint';
+    modelName: string;
+    constraintType: 'foreignKey' | 'primaryKey' | 'unique';
+    details: string;
+}
+export interface DropConstraint {
+    kind: 'DropConstraint';
+    modelName: string;
+    constraintType: 'foreignKey' | 'primaryKey' | 'unique';
+    details: string;
+}
+export interface CreateExtension {
+    kind: 'CreateExtension';
+    extensionName: string;
+}
+export interface DropExtension {
+    kind: 'DropExtension';
+    extensionName: string;
+}
+export interface CreateTrigger {
+    kind: 'CreateTrigger';
+    modelName: string;
+    signature: string;
+}
+export interface DropTrigger {
+    kind: 'DropTrigger';
+    modelName: string;
+    signature: string;
+}

package/dist/sql-generator/migration-types.js

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

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

@@ -0,0 +1,6 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export declare class SqlGenerator {
+    generate(schema: Schema): string;
+    generateFromSource(source: string): string;
+}
+export { toSnakeCase, toTableName } from './utils/snake-case.js';

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

@@ -0,0 +1,26 @@
+import { parse } from '../schema-dsl/index.js';
+import { generateDropTables } from './generators/drop-tables.js';
+import { generateEnums } from './generators/enums.js';
+import { generateExtensions } from './generators/extensions.js';
+import { generateForeignKeys } from './generators/foreign-keys.js';
+import { generateIndexes } from './generators/indexes.js';
+import { generateTables } from './generators/tables.js';
+import { generateTriggers } from './generators/triggers.js';
+export class SqlGenerator {
+    generate(schema) {
+        const sections = [
+            generateExtensions(schema),
+            generateEnums(schema),
+            generateDropTables(schema),
+            generateTables(schema),
+            generateForeignKeys(schema),
+            generateIndexes(schema),
+            generateTriggers(schema),
+        ];
+        return `${sections.join('\n')}\n`;
+    }
+    generateFromSource(source) {
+        return this.generate(parse(source));
+    }
+}
+export { toSnakeCase, toTableName } from './utils/snake-case.js';

package/dist/sql-generator/utils/ast-helpers.d.ts

@@ -0,0 +1,58 @@
+import type { Attribute, AttributeArgs, Directive, Field, KeyValueArgs, Model, Schema, TypeExpr, Value } from '../../schema-dsl/ast.js';
+export interface PrimaryKeyInfo {
+    fields: string[];
+    composite: boolean;
+}
+export interface ForeignKeyInfo {
+    sourceModel: string;
+    sourceTable: string;
+    sourceColumns: string[];
+    targetModel: string;
+    targetTable: string;
+    targetColumns: string[];
+    onDelete?: string;
+    onUpdate?: string;
+}
+export declare function getModelNames(schema: Schema): Set<string>;
+export declare function getEnumNames(schema: Schema): Set<string>;
+export declare function isStoredField(field: Field, modelNames: Set<string>): boolean;
+export declare function getStoredFields(model: Model, modelNames: Set<string>): Field[];
+export declare function getFieldAttribute(field: Field, name: string): Attribute | undefined;
+export declare function getModelAttribute(model: Model, name: string): Attribute | undefined;
+export declare function getDirective(model: Model, name: string): Directive | undefined;
+export declare function getDirectives(model: Model, name: string): Directive[];
+export declare function assertKeyValueArgs(args: AttributeArgs | undefined): KeyValueArgs;
+export declare function getKvPair(args: KeyValueArgs, key: string): import("../../schema-dsl/ast.js").KeyValuePair;
+export declare function getOptionalKvPair(args: KeyValueArgs, key: string): import("../../schema-dsl/ast.js").KeyValuePair | undefined;
+export declare function getIdentifierNames(value: Value): string[];
+export declare function fieldHasAttribute(field: Field, name: string): boolean;
+export declare function getPrimaryKey(model: Model): PrimaryKeyInfo | undefined;
+export declare function getDefaultExpression(field: Field, enumNames: Set<string>): string | undefined;
+export declare function collectValidationComments(field: Field): string[];
+export declare function mapReferentialAction(value: Value | undefined): string | undefined;
+export declare function collectForeignKeys(schema: Schema): ForeignKeyInfo[];
+export declare function serializeColumnType(type: TypeExpr, enumNames: Set<string>): string;
+export declare function serializeDefault(field: Field, enumNames: Set<string>): string | undefined;
+export declare function getFieldSnakeNameMap(model: Model, modelNames: Set<string>): Map<string, string>;
+export declare function transformWhereClause(where: string, fieldNameMap: Map<string, string>): string;
+export declare function serializeForeignKey(foreignKey: ForeignKeyInfo): string;
+export declare function parseForeignKeySignature(signature: string): ForeignKeyInfo;
+export declare function normalizeIndexDirective(directive: Directive, model: Model, modelNames: Set<string>): {
+    fields: string[];
+    where?: string;
+    unique?: boolean;
+    name?: string;
+    type?: string;
+};
+export interface NormalizedTrigger {
+    timing: string;
+    event: string;
+    level: string;
+    execute: string;
+}
+export interface TriggerNames {
+    functionName: string;
+    triggerName: string;
+}
+export declare function normalizeTriggerDirective(directive: Directive): NormalizedTrigger;
+export declare function resolveTriggerNames(model: Model, timing: string, event: string): TriggerNames;