@lyku/lockstep-pg 0.1.1

package/src/mapColumnType.js

@@ -0,0 +1,63 @@
+import { mapArrayType } from './mapArrayType';
+import { mapBigintType } from './mapBigintType';
+import { mapIntegerType } from './mapIntegerType';
+import { mapVarcharType } from './mapVarcharType';
+import { mapTextType } from './mapTextType';
+import { mapTimestamptzType } from './mapTimestamptzType';
+import { mapCharType } from './mapCharType';
+import { mapBigserialType } from './mapBigserialType';
+import { mapSerialType } from './mapSerialType';
+export function mapColumnType(name, columnSchema) {
+    // console.log('switching', columnSchema.type);
+    switch (columnSchema.type) {
+        case 'double precision':
+        case 'float8':
+            return 'DOUBLE PRECISION';
+        case 'real':
+        case 'float4':
+            return 'REAL';
+        case 'date':
+            return 'DATE';
+        case 'integer':
+        case 'int':
+        case 'int4':
+            return mapIntegerType(name, columnSchema);
+        case 'int2':
+        case 'smallint':
+            return 'SMALLINT';
+        case 'bigint':
+            return mapBigintType(name, columnSchema);
+        case 'bigserial':
+            return mapBigserialType(name, columnSchema);
+        case 'serial':
+            return mapSerialType(name, columnSchema);
+        case 'boolean':
+            return 'BOOLEAN';
+        case 'char':
+        case 'character':
+        case 'bpchar':
+            return mapCharType(name, columnSchema);
+        case 'text':
+            return mapTextType(name, columnSchema);
+        case 'varchar':
+        case 'character varying':
+            return mapVarcharType(name, columnSchema);
+        case 'timestamp':
+            return 'TIMESTAMP';
+        case 'timestamptz':
+            return mapTimestamptzType(name, columnSchema);
+        case 'numeric':
+            return 'NUMERIC';
+        case 'jsonb':
+            return 'JSONB';
+        case 'enum':
+            return `TEXT CHECK ("${name}" IN (${columnSchema.enum
+                .map((e) => `'${e}'`)
+                .join(', ')}))`;
+        case 'array':
+            return mapArrayType(name, columnSchema);
+        default:
+            throw new Error(`Unsupported column type: ${columnSchema.type}`);
+    }
+}
+//# sourceMappingURL=mapColumnType.js.map

package/src/mapColumnType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapColumnType.js","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapColumnType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,MAAM,UAAU,aAAa,CAC5B,IAAY,EACZ,YAAiC;IAEjC,+CAA+C;IAC/C,QAAQ,YAAY,CAAC,IAAI,EAAE,CAAC;QAC3B,KAAK,kBAAkB,CAAC;QACxB,KAAK,QAAQ;YACZ,OAAO,kBAAkB,CAAC;QAC3B,KAAK,MAAM,CAAC;QACZ,KAAK,QAAQ;YACZ,OAAO,MAAM,CAAC;QACf,KAAK,MAAM;YACV,OAAO,MAAM,CAAC;QACf,KAAK,SAAS,CAAC;QACf,KAAK,KAAK,CAAC;QACX,KAAK,MAAM;YACV,OAAO,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC3C,KAAK,MAAM,CAAC;QACZ,KAAK,UAAU;YACd,OAAO,UAAU,CAAC;QACnB,KAAK,QAAQ;YACZ,OAAO,aAAa,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC1C,KAAK,WAAW;YACf,OAAO,gBAAgB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC7C,KAAK,QAAQ;YACZ,OAAO,aAAa,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC1C,KAAK,SAAS;YACb,OAAO,SAAS,CAAC;QAClB,KAAK,MAAM,CAAC;QACZ,KAAK,WAAW,CAAC;QACjB,KAAK,QAAQ;YACZ,OAAO,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACxC,KAAK,MAAM;YACV,OAAO,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACxC,KAAK,SAAS,CAAC;QACf,KAAK,mBAAmB;YACvB,OAAO,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC3C,KAAK,WAAW;YACf,OAAO,WAAW,CAAC;QACpB,KAAK,aAAa;YACjB,OAAO,kBAAkB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAC/C,KAAK,SAAS;YACb,OAAO,SAAS,CAAC;QAClB,KAAK,OAAO;YACX,OAAO,OAAO,CAAC;QAChB,KAAK,MAAM;YACV,OAAO,gBAAgB,IAAI,SAAS,YAAY,CAAC,IAAI;iBACnD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;iBACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;QAClB,KAAK,OAAO;YACX,OAAO,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QACzC;YACC,MAAM,IAAI,KAAK,CAAC,4BAA4B,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC;IACnE,CAAC;AACF,CAAC"}

package/src/mapIntegerType.d.ts

@@ -0,0 +1,3 @@
+import { IntegerColumnModel } from '@lyku/lockstep-core';
+export declare const mapIntegerType: (name: string, columnSchema: IntegerColumnModel) => string;
+//# sourceMappingURL=mapIntegerType.d.ts.map

package/src/mapIntegerType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapIntegerType.d.ts","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapIntegerType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAGzD,eAAO,MAAM,cAAc,GAC1B,MAAM,MAAM,EACZ,cAAc,kBAAkB,KAC9B,MAUF,CAAC"}

package/src/mapIntegerType.js

@@ -0,0 +1,12 @@
+import { numberChecks } from './numberChecks';
+export const mapIntegerType = (name, columnSchema) => {
+    const constraints = numberChecks(name, columnSchema);
+    if (columnSchema.primaryKey) {
+        constraints.push('PRIMARY KEY');
+    }
+    if (columnSchema.unique) {
+        constraints.push('UNIQUE');
+    }
+    return `INTEGER${constraints.length ? ' ' + constraints.join(' ') : ''}`;
+};
+//# sourceMappingURL=mapIntegerType.js.map

package/src/mapIntegerType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapIntegerType.js","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapIntegerType.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,CAAC,MAAM,cAAc,GAAG,CAC7B,IAAY,EACZ,YAAgC,EACvB,EAAE;IACX,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAErD,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QAC7B,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,UAAU,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AAC1E,CAAC,CAAC"}

package/src/mapSerialType.d.ts

@@ -0,0 +1,3 @@
+import { SerialColumnModel } from '@lyku/lockstep-core';
+export declare const mapSerialType: (name: string, columnSchema: SerialColumnModel) => string;
+//# sourceMappingURL=mapSerialType.d.ts.map

package/src/mapSerialType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapSerialType.d.ts","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapSerialType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGxD,eAAO,MAAM,aAAa,GACzB,MAAM,MAAM,EACZ,cAAc,iBAAiB,KAC7B,MAUF,CAAC"}

package/src/mapSerialType.js

@@ -0,0 +1,12 @@
+import { numberChecks } from './numberChecks';
+export const mapSerialType = (name, columnSchema) => {
+    const constraints = numberChecks(name, columnSchema);
+    if (columnSchema.primaryKey) {
+        constraints.push('PRIMARY KEY');
+    }
+    if (columnSchema.unique) {
+        constraints.push('UNIQUE');
+    }
+    return `SERIAL${constraints.length ? ' ' + constraints.join(' ') : ''}`;
+};
+//# sourceMappingURL=mapSerialType.js.map

package/src/mapSerialType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapSerialType.js","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapSerialType.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,CAAC,MAAM,aAAa,GAAG,CAC5B,IAAY,EACZ,YAA+B,EACtB,EAAE;IACX,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAErD,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QAC7B,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AACzE,CAAC,CAAC"}

package/src/mapTextType.d.ts

@@ -0,0 +1,3 @@
+import { TextColumnModel } from '@lyku/lockstep-core';
+export declare const mapTextType: (name: string, columnSchema: TextColumnModel) => string;
+//# sourceMappingURL=mapTextType.d.ts.map

package/src/mapTextType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapTextType.d.ts","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapTextType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAYtD,eAAO,MAAM,WAAW,GACvB,MAAM,MAAM,EACZ,cAAc,eAAe,KAC3B,MAwCF,CAAC"}

package/src/mapTextType.js

@@ -0,0 +1,44 @@
+// Convert regex pattern like ^(a|b|c)$ to CHECK IN constraint
+function patternToCheck(name, pattern) {
+    const match = pattern.match(/^\^\(([^)]+)\)\$$/);
+    if (match) {
+        const values = match[1].split('|').map((v) => `'${v}'`);
+        return `CHECK ("${name}" IN (${values.join(', ')}))`;
+    }
+    return null;
+}
+export const mapTextType = (name, columnSchema) => {
+    // console.log('mapping text', name, columnSchema, '/text');
+    const constraints = [];
+    if (columnSchema.primaryKey) {
+        constraints.push('PRIMARY KEY');
+    }
+    if (columnSchema.unique) {
+        constraints.push('UNIQUE');
+    }
+    if (columnSchema.generated) {
+        constraints.push(`GENERATED ALWAYS AS (${columnSchema.generated.as})${columnSchema.generated.stored ? ' STORED' : ''}`);
+    }
+    if (columnSchema.checks) {
+        constraints.push(...columnSchema.checks.map((check) => `CHECK (${check})`));
+    }
+    // Convert pattern to CHECK IN constraint for enum-like values
+    if ('pattern' in columnSchema && columnSchema.pattern) {
+        const check = patternToCheck(name, columnSchema.pattern);
+        if (check) {
+            constraints.push(check);
+        }
+    }
+    if (columnSchema.maxLength) {
+        constraints.push(`CHECK (length("${name}") <= ${columnSchema.maxLength})`);
+    }
+    if (columnSchema.minLength) {
+        constraints.push(`CHECK (length("${name}") >= ${columnSchema.minLength})`);
+    }
+    // if (columnSchema.default !== undefined) {
+    //     constraints.push(`DEFAULT '${columnSchema.default}'`);
+    // }
+    const length = 'length' in columnSchema ? `(${columnSchema.length})` : '';
+    return `TEXT${length}${constraints.length ? ' ' + constraints.join(' ') : ''}`;
+};
+//# sourceMappingURL=mapTextType.js.map

package/src/mapTextType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapTextType.js","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapTextType.ts"],"names":[],"mappings":"AAEA,8DAA8D;AAC9D,SAAS,cAAc,CAAC,IAAY,EAAE,OAAe;IACpD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACjD,IAAI,KAAK,EAAE,CAAC;QACX,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACxD,OAAO,WAAW,IAAI,SAAS,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACtD,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAG,CAC1B,IAAY,EACZ,YAA6B,EACpB,EAAE;IACX,4DAA4D;IAC5D,MAAM,WAAW,GAAa,EAAE,CAAC;IAEjC,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QAC7B,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;QAC5B,WAAW,CAAC,IAAI,CACf,wBAAwB,YAAY,CAAC,SAAS,CAAC,EAAE,IAChD,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAC7C,EAAE,CACF,CAAC;IACH,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,KAAK,GAAG,CAAC,CAAC,CAAC;IAC7E,CAAC;IACD,8DAA8D;IAC9D,IAAI,SAAS,IAAI,YAAY,IAAI,YAAY,CAAC,OAAO,EAAE,CAAC;QACvD,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,OAAiB,CAAC,CAAC;QACnE,IAAI,KAAK,EAAE,CAAC;YACX,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;IACF,CAAC;IACD,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;QAC5B,WAAW,CAAC,IAAI,CAAC,kBAAkB,IAAI,SAAS,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;QAC5B,WAAW,CAAC,IAAI,CAAC,kBAAkB,IAAI,SAAS,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,4CAA4C;IAC5C,6DAA6D;IAC7D,IAAI;IACJ,MAAM,MAAM,GAAG,QAAQ,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1E,OAAO,OAAO,MAAM,GACnB,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EACpD,EAAE,CAAC;AACJ,CAAC,CAAC"}

package/src/mapTimestamptzType.d.ts

@@ -0,0 +1,3 @@
+import { Timestamptz } from '@lyku/lockstep-core';
+export declare const mapTimestamptzType: (name: string, columnSchema: Timestamptz) => string;
+//# sourceMappingURL=mapTimestamptzType.d.ts.map

package/src/mapTimestamptzType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapTimestamptzType.d.ts","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapTimestamptzType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,eAAO,MAAM,kBAAkB,GAC9B,MAAM,MAAM,EACZ,cAAc,WAAW,KACvB,MAWF,CAAC"}

package/src/mapTimestamptzType.js

@@ -0,0 +1,13 @@
+import { timestampChecks } from './timestampChecks';
+export const mapTimestamptzType = (name, columnSchema) => {
+    const constraints = timestampChecks(name, columnSchema);
+    if (columnSchema.primaryKey) {
+        constraints.push('PRIMARY KEY');
+    }
+    if (columnSchema.unique) {
+        constraints.push('UNIQUE');
+    }
+    // Note: DEFAULT is handled by migrate.ts to avoid duplication
+    return `TIMESTAMPTZ${constraints.length ? ' ' + constraints.join(' ') : ''}`;
+};
+//# sourceMappingURL=mapTimestamptzType.js.map

package/src/mapTimestamptzType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapTimestamptzType.js","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapTimestamptzType.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CACjC,IAAY,EACZ,YAAyB,EAChB,EAAE;IACX,MAAM,WAAW,GAAG,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAExD,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QAC7B,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IACD,8DAA8D;IAC9D,OAAO,cAAc,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;AAC9E,CAAC,CAAC"}

package/src/mapVarcharType.d.ts

@@ -0,0 +1,3 @@
+import { VarcharColumnModel } from '@lyku/lockstep-core';
+export declare const mapVarcharType: (name: string, columnSchema: VarcharColumnModel) => string;
+//# sourceMappingURL=mapVarcharType.d.ts.map

package/src/mapVarcharType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapVarcharType.d.ts","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapVarcharType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAYzD,eAAO,MAAM,cAAc,GAC1B,MAAM,MAAM,EACZ,cAAc,kBAAkB,KAC9B,MAwCF,CAAC"}

package/src/mapVarcharType.js

@@ -0,0 +1,44 @@
+// Convert regex pattern like ^(a|b|c)$ to CHECK IN constraint
+function patternToCheck(name, pattern) {
+    const match = pattern.match(/^\^\(([^)]+)\)\$$/);
+    if (match) {
+        const values = match[1].split('|').map((v) => `'${v}'`);
+        return `CHECK ("${name}" IN (${values.join(', ')}))`;
+    }
+    return null;
+}
+export const mapVarcharType = (name, columnSchema) => {
+    // console.log('mapping varchar', name, columnSchema, '/varchar');
+    const constraints = [];
+    if (columnSchema.primaryKey) {
+        constraints.push('PRIMARY KEY');
+    }
+    if (columnSchema.unique) {
+        constraints.push('UNIQUE');
+    }
+    if (columnSchema.generated) {
+        constraints.push(`GENERATED ALWAYS AS (${columnSchema.generated.as})${columnSchema.generated.stored ? ' STORED' : ''}`);
+    }
+    if (columnSchema.checks) {
+        constraints.push(...columnSchema.checks.map((check) => `CHECK (${check})`));
+    }
+    // Convert pattern to CHECK IN constraint for enum-like values
+    if ('pattern' in columnSchema && columnSchema.pattern) {
+        const check = patternToCheck(name, columnSchema.pattern);
+        if (check) {
+            constraints.push(check);
+        }
+    }
+    if (columnSchema.maxLength) {
+        constraints.push(`CHECK (length("${name}") <= ${columnSchema.maxLength})`);
+    }
+    if (columnSchema.minLength) {
+        constraints.push(`CHECK (length("${name}") >= ${columnSchema.minLength})`);
+    }
+    // if (columnSchema.default !== undefined) {
+    //     constraints.push(`DEFAULT '${columnSchema.default}'`);
+    // }
+    const length = 'length' in columnSchema ? `(${columnSchema.length})` : '';
+    return `VARCHAR${length}${constraints.length ? ' ' + constraints.join(' ') : ''}`;
+};
+//# sourceMappingURL=mapVarcharType.js.map

package/src/mapVarcharType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapVarcharType.js","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/mapVarcharType.ts"],"names":[],"mappings":"AAEA,8DAA8D;AAC9D,SAAS,cAAc,CAAC,IAAY,EAAE,OAAe;IACpD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACjD,IAAI,KAAK,EAAE,CAAC;QACX,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACxD,OAAO,WAAW,IAAI,SAAS,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACtD,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,CAC7B,IAAY,EACZ,YAAgC,EACvB,EAAE;IACX,kEAAkE;IAClE,MAAM,WAAW,GAAa,EAAE,CAAC;IAEjC,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;QAC7B,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACjC,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;QAC5B,WAAW,CAAC,IAAI,CACf,wBAAwB,YAAY,CAAC,SAAS,CAAC,EAAE,IAChD,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAC7C,EAAE,CACF,CAAC;IACH,CAAC;IACD,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;QACzB,WAAW,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,KAAK,GAAG,CAAC,CAAC,CAAC;IAC7E,CAAC;IACD,8DAA8D;IAC9D,IAAI,SAAS,IAAI,YAAY,IAAI,YAAY,CAAC,OAAO,EAAE,CAAC;QACvD,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,OAAiB,CAAC,CAAC;QACnE,IAAI,KAAK,EAAE,CAAC;YACX,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;IACF,CAAC;IACD,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;QAC5B,WAAW,CAAC,IAAI,CAAC,kBAAkB,IAAI,SAAS,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC;QAC5B,WAAW,CAAC,IAAI,CAAC,kBAAkB,IAAI,SAAS,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC;IAC5E,CAAC;IACD,4CAA4C;IAC5C,6DAA6D;IAC7D,IAAI;IACJ,MAAM,MAAM,GAAG,QAAQ,IAAI,YAAY,CAAC,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1E,OAAO,UAAU,MAAM,GACtB,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EACpD,EAAE,CAAC;AACJ,CAAC,CAAC"}

package/src/migrate.d.ts

@@ -0,0 +1,13 @@
+import { type DataformConfig, type Drift } from './drift';
+interface MigrationResult {
+    safe: string[];
+    destructive: string[];
+}
+export declare function driftToSql(drifts: Drift[], config: DataformConfig): MigrationResult;
+export declare function generateMigration(connectionString: string, config: DataformConfig): Promise<{
+    safe: string;
+    destructive: string;
+    driftCount: number;
+}>;
+export {};
+//# sourceMappingURL=migrate.d.ts.map

package/src/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../../../libs/lockstep-pg/src/migrate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAuBvE,UAAU,eAAe;IACxB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACtB;AAmBD,wBAAgB,UAAU,CACzB,MAAM,EAAE,KAAK,EAAE,EACf,MAAM,EAAE,cAAc,GACpB,eAAe,CAoXjB;AAED,wBAAsB,iBAAiB,CACtC,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,cAAc,GACpB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CA2CpE"}

package/src/migrate.js

@@ -0,0 +1,350 @@
+import { detectDrift } from './drift';
+import { mapColumnType } from './mapColumnType';
+import { buildTableCreationCommand } from './createTable';
+import { buildTableIndexCommands } from './buildTableIndexCommand';
+import { buildTableTriggerCommands } from './buildTableTriggerCommands';
+import { dateToPostgresString } from './dateToPostgresString';
+const escapeString = (str) => {
+    if (str === undefined || str === null)
+        return 'NULL';
+    return `'${str.replace(/'/g, "''")}'`;
+};
+const formatSqlValue = (value) => {
+    if (value === undefined || value === null)
+        return 'NULL';
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'number')
+        return value.toString();
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (value instanceof Date)
+        return `'${dateToPostgresString(value)}'`;
+    if (typeof value === 'string')
+        return escapeString(value);
+    return 'NULL';
+};
+function formatDefault(def) {
+    if (def === null)
+        return 'NULL';
+    if (typeof def === 'object' && def !== null && 'sql' in def) {
+        return def.sql;
+    }
+    if (typeof def === 'string')
+        return `'${def}'`;
+    if (typeof def === 'boolean')
+        return def ? 'TRUE' : 'FALSE';
+    return String(def);
+}
+function getExpectedSqlType(columnName, schema) {
+    return mapColumnType(columnName, schema);
+}
+export function driftToSql(drifts, config) {
+    const safe = [];
+    const destructive = [];
+    for (const drift of drifts) {
+        switch (drift.type) {
+            case 'missing_table': {
+                const tableModel = config.tables[drift.table];
+                if (!tableModel) {
+                    safe.push(`-- WARNING: Table "${drift.table}" not found in config`);
+                    break;
+                }
+                safe.push(`-- Create table: ${drift.table}`);
+                safe.push(buildTableCreationCommand(drift.table, tableModel));
+                const indexCommands = buildTableIndexCommands(drift.table, tableModel);
+                if (indexCommands.length > 0) {
+                    safe.push(...indexCommands);
+                }
+                const triggerCommands = buildTableTriggerCommands(drift.table, tableModel);
+                if (triggerCommands.length > 0) {
+                    safe.push('');
+                    safe.push(`-- Triggers for: ${drift.table}`);
+                    safe.push(...triggerCommands);
+                }
+                safe.push('');
+                break;
+            }
+            case 'missing_column': {
+                const tableModel = config.tables[drift.table];
+                if (!tableModel || !('properties' in tableModel.schema)) {
+                    safe.push(`-- WARNING: Cannot find schema for "${drift.table}"`);
+                    break;
+                }
+                const columnName = drift.column;
+                if (!columnName) {
+                    safe.push(`-- WARNING: Missing column name for drift in "${drift.table}"`);
+                    break;
+                }
+                // eslint-disable-next-line security/detect-object-injection -- columnName is from schema
+                const colSchema = tableModel.schema.properties[columnName];
+                if (!colSchema) {
+                    safe.push(`-- WARNING: Column "${columnName}" not found in schema for "${drift.table}"`);
+                    break;
+                }
+                const required = 'required' in tableModel.schema
+                    ? tableModel.schema.required
+                    : [];
+                const isRequired = required.includes(columnName);
+                const sqlType = getExpectedSqlType(columnName, colSchema);
+                const hasDefault = 'default' in colSchema && colSchema.default !== undefined;
+                if (isRequired && !hasDefault) {
+                    safe.push(`-- Add column "${columnName}" to "${drift.table}" (NOT NULL, requires backfill)`);
+                    safe.push(`ALTER TABLE "${drift.table}" ADD COLUMN IF NOT EXISTS "${columnName}" ${sqlType};`);
+                    safe.push(`-- TODO: Backfill existing rows with appropriate value:`);
+                    safe.push(`-- UPDATE "${drift.table}" SET "${columnName}" = <default_value> WHERE "${columnName}" IS NULL;`);
+                    safe.push(`ALTER TABLE "${drift.table}" ALTER COLUMN "${columnName}" SET NOT NULL;`);
+                }
+                else {
+                    const notNull = isRequired ? ' NOT NULL' : '';
+                    const defaultClause = hasDefault
+                        ? ` DEFAULT ${formatDefault(colSchema.default)}`
+                        : '';
+                    safe.push(`-- Add column "${columnName}" to "${drift.table}"`);
+                    safe.push(`ALTER TABLE "${drift.table}" ADD COLUMN IF NOT EXISTS "${columnName}" ${sqlType}${defaultClause}${notNull};`);
+                }
+                safe.push('');
+                break;
+            }
+            case 'missing_index': {
+                const match = drift.details.match(/column\(s\): (.+)$/);
+                if (match) {
+                    const cols = match[1].split(', ').map((c) => c.trim());
+                    const colNames = cols.map((c) => c.split(' ')[0]);
+                    const indexName = `idx_${drift.table}_${colNames.join('_')}`;
+                    const formattedCols = cols.map((c) => {
+                        const parts = c.split(' ');
+                        const colName = parts[0];
+                        const modifiers = parts.slice(1).join(' ');
+                        return modifiers ? `"${colName}" ${modifiers}` : `"${colName}"`;
+                    });
+                    safe.push(`-- Add missing index on "${drift.table}"`);
+                    safe.push(`CREATE INDEX IF NOT EXISTS "${indexName}" ON "${drift.table}" (${formattedCols.join(', ')});`);
+                    safe.push('');
+                }
+                break;
+            }
+            case 'column_type_mismatch': {
+                const columnName = drift.column ?? '';
+                let sqlType;
+                let castType;
+                if (drift.expected === 'array') {
+                    const tableModel = config.tables[drift.table];
+                    let arrayItemType = null;
+                    if (tableModel && 'properties' in tableModel.schema) {
+                        // eslint-disable-next-line security/detect-object-injection -- columnName is from schema
+                        const colSchema = tableModel.schema.properties[columnName];
+                        if (colSchema &&
+                            colSchema.type === 'array' &&
+                            'items' in colSchema &&
+                            colSchema.items &&
+                            typeof colSchema.items === 'object') {
+                            const items = colSchema.items;
+                            if (items.type) {
+                                arrayItemType = items.type;
+                                if (arrayItemType === 'int8')
+                                    arrayItemType = 'bigint';
+                                if (arrayItemType === 'int4' || arrayItemType === 'int')
+                                    arrayItemType = 'integer';
+                                if (arrayItemType === 'int2')
+                                    arrayItemType = 'smallint';
+                                if (arrayItemType === 'float8')
+                                    arrayItemType = 'double precision';
+                                if (arrayItemType === 'float4')
+                                    arrayItemType = 'real';
+                                if (arrayItemType === 'bool')
+                                    arrayItemType = 'boolean';
+                            }
+                        }
+                    }
+                    const simpleArrayTypes = new Set([
+                        'bigint',
+                        'integer',
+                        'smallint',
+                        'double precision',
+                        'real',
+                        'text',
+                        'varchar',
+                        'char',
+                        'boolean',
+                        'timestamptz',
+                        'timestamp',
+                        'date',
+                    ]);
+                    if (arrayItemType && simpleArrayTypes.has(arrayItemType)) {
+                        const pgType = arrayItemType.toUpperCase();
+                        sqlType = `${pgType}[]`;
+                        castType = `${arrayItemType}[]`;
+                    }
+                    else {
+                        sqlType = 'JSONB';
+                        castType = 'jsonb';
+                    }
+                }
+                else {
+                    sqlType = drift.expected?.toUpperCase() ?? 'TEXT';
+                    castType = drift.expected ?? 'text';
+                }
+                safe.push(`-- Type change for "${drift.table}"."${columnName}": ${drift.actual} → ${drift.expected}`);
+                safe.push(`-- WARNING: Verify data compatibility before running`);
+                safe.push(`ALTER TABLE "${drift.table}" ALTER COLUMN "${columnName}" TYPE ${sqlType} USING "${columnName}"::${castType};`);
+                safe.push('');
+                break;
+            }
+            case 'nullable_mismatch': {
+                const columnName = drift.column ?? '';
+                if (drift.expected === 'not null') {
+                    safe.push(`-- Make "${drift.table}"."${columnName}" NOT NULL`);
+                    safe.push(`-- WARNING: Ensure no NULL values exist first`);
+                    safe.push(`ALTER TABLE "${drift.table}" ALTER COLUMN "${columnName}" SET NOT NULL;`);
+                }
+                else {
+                    safe.push(`-- Make "${drift.table}"."${columnName}" nullable`);
+                    safe.push(`ALTER TABLE "${drift.table}" ALTER COLUMN "${columnName}" DROP NOT NULL;`);
+                }
+                safe.push('');
+                break;
+            }
+            case 'extra_table': {
+                destructive.push(`-- Drop table "${drift.table}" (exists in DB but not in schema)`);
+                destructive.push(`DROP TABLE IF EXISTS "${drift.table}" CASCADE;`);
+                destructive.push('');
+                break;
+            }
+            case 'extra_column': {
+                const columnName = drift.column ?? '';
+                destructive.push(`-- Drop column "${columnName}" from "${drift.table}" (exists in DB but not in schema)`);
+                destructive.push(`ALTER TABLE "${drift.table}" DROP COLUMN IF EXISTS "${columnName}";`);
+                destructive.push('');
+                break;
+            }
+            case 'extra_index': {
+                destructive.push(`-- ${drift.details}`);
+                destructive.push(`-- DROP INDEX IF EXISTS "...";`);
+                destructive.push('');
+                break;
+            }
+            case 'missing_stock_doc': {
+                const tableModel = config.tables[drift.table];
+                if (!tableModel || !tableModel.docs) {
+                    safe.push(`-- WARNING: Cannot find docs for table "${drift.table}"`);
+                    break;
+                }
+                const primaryKey = tableModel.primaryKey || 'id';
+                const doc = tableModel.docs.find((d) => d &&
+                    typeof d === 'object' &&
+                    !Array.isArray(d) &&
+                    'id' in d &&
+                    String(d['id']) ===
+                        String(drift.docId));
+                if (!doc) {
+                    safe.push(`-- WARNING: Stock doc id=${drift.docId} not found in config for "${drift.table}"`);
+                    break;
+                }
+                const columns = Object.keys(doc);
+                const values = columns.map((col) => 
+                // eslint-disable-next-line security/detect-object-injection -- col is from Object.keys
+                formatSqlValue(doc[col]));
+                safe.push(`-- Insert missing stock doc: ${drift.details}`);
+                safe.push(`INSERT INTO "${drift.table}" (${columns.map((c) => `"${c}"`).join(', ')})`);
+                safe.push(`VALUES (${values.join(', ')})`);
+                safe.push(`ON CONFLICT ("${primaryKey}") DO NOTHING;`);
+                safe.push('');
+                break;
+            }
+            case 'check_constraint_mismatch': {
+                const columnName = drift.column ?? '';
+                const constraintName = drift.constraintName;
+                const tableModel = config.tables[drift.table];
+                if (!tableModel || !('properties' in tableModel.schema)) {
+                    safe.push(`-- WARNING: Cannot find schema for "${drift.table}"`);
+                    break;
+                }
+                // eslint-disable-next-line security/detect-object-injection -- columnName is from schema
+                const colSchema = tableModel.schema.properties[columnName];
+                if (!colSchema || colSchema.type !== 'enum' || !colSchema.enum) {
+                    safe.push(`-- WARNING: Column "${columnName}" is not an enum in schema`);
+                    break;
+                }
+                const newValues = colSchema.enum.map((v) => `'${v}'`).join(', ');
+                const newConstraintName = `${drift.table}_${columnName}_check`;
+                safe.push(`-- Update CHECK constraint for "${drift.table}"."${columnName}"`);
+                safe.push(`-- Old values: ${drift.actual}`);
+                safe.push(`-- New values: ${drift.expected}`);
+                if (constraintName) {
+                    safe.push(`ALTER TABLE "${drift.table}" DROP CONSTRAINT IF EXISTS "${constraintName}";`);
+                }
+                if (constraintName !== newConstraintName) {
+                    safe.push(`ALTER TABLE "${drift.table}" DROP CONSTRAINT IF EXISTS "${newConstraintName}";`);
+                }
+                safe.push(`ALTER TABLE "${drift.table}" ADD CONSTRAINT "${newConstraintName}" CHECK ("${columnName}" IN (${newValues}));`);
+                safe.push('');
+                break;
+            }
+            case 'missing_constraint': {
+                const columnName = drift.column ?? '';
+                const tableModel = config.tables[drift.table];
+                if (!tableModel || !('properties' in tableModel.schema)) {
+                    safe.push(`-- WARNING: Cannot find schema for "${drift.table}"`);
+                    break;
+                }
+                // eslint-disable-next-line security/detect-object-injection -- columnName is from schema
+                const colSchema = tableModel.schema.properties[columnName];
+                if (!colSchema || colSchema.type !== 'enum' || !colSchema.enum) {
+                    safe.push(`-- WARNING: Column "${columnName}" is not an enum in schema`);
+                    break;
+                }
+                const newValues = colSchema.enum.map((v) => `'${v}'`).join(', ');
+                const newConstraintName = `${drift.table}_${columnName}_check`;
+                safe.push(`-- Add missing CHECK constraint for "${drift.table}"."${columnName}"`);
+                safe.push(`ALTER TABLE "${drift.table}" DROP CONSTRAINT IF EXISTS "${newConstraintName}";`);
+                safe.push(`ALTER TABLE "${drift.table}" ADD CONSTRAINT "${newConstraintName}" CHECK ("${columnName}" IN (${newValues}));`);
+                safe.push('');
+                break;
+            }
+            default:
+                safe.push(`-- Unhandled drift type: ${drift.type}`);
+                safe.push(`-- ${drift.details}`);
+                safe.push('');
+        }
+    }
+    return { safe, destructive };
+}
+export async function generateMigration(connectionString, config) {
+    const drifts = await detectDrift(connectionString, config);
+    if (drifts.length === 0) {
+        return { safe: '', destructive: '', driftCount: 0 };
+    }
+    const { safe, destructive } = driftToSql(drifts, config);
+    const timestamp = new Date().toISOString();
+    const safeContent = safe.length > 0
+        ? [
+            '-- Schema Migration (Safe Operations)',
+            `-- Generated: ${timestamp}`,
+            `-- Drifts detected: ${drifts.length}`,
+            '',
+            'BEGIN;',
+            '',
+            ...safe,
+            'COMMIT;',
+        ].join('\n')
+        : '';
+    const destructiveContent = destructive.length > 0
+        ? [
+            '-- Schema Migration (DESTRUCTIVE Operations)',
+            `-- Generated: ${timestamp}`,
+            '-- WARNING: These operations will DELETE data!',
+            '',
+            'BEGIN;',
+            '',
+            ...destructive,
+            'COMMIT;',
+        ].join('\n')
+        : '';
+    return {
+        safe: safeContent,
+        destructive: destructiveContent,
+        driftCount: drifts.length,
+    };
+}
+//# sourceMappingURL=migrate.js.map