@apso/cli 0.8.5 → 0.10.1

package/dist/lib/migrate/sandbox.js

@@ -0,0 +1,337 @@
+"use strict";
+/**
+ * Migration Sandbox
+ *
+ * The core migration testing engine. Uses PGlite (in-process Postgres) to:
+ * 1. Establish a baseline schema from the previous snapshot
+ * 2. Compute the diff against the current schema
+ * 3. Generate and test migration SQL locally
+ *
+ * This validates migrations before anything touches a remote database.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetSandbox = exports.applyMigration = exports.runMigrationSandbox = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const paths_1 = require("../config/paths");
+const snapshot_1 = require("./snapshot");
+const field_1 = require("../utils/field");
+const casing_1 = require("../utils/casing");
+/**
+ * Get the sandbox data directory for PGlite persistence.
+ */
+function getSandboxDataDir(projectDir) {
+    return path.join((0, paths_1.getProjectConfigDir)(projectDir), "sandbox", "pgdata");
+}
+/**
+ * Clear TypeORM's global metadata storage.
+ * Required between sandbox runs to prevent metadata from previous
+ * entity classes leaking into subsequent DataSource instances.
+ */
+function clearTypeOrmMetadata() {
+    const typeorm = require("typeorm");
+    const storage = typeorm.getMetadataArgsStorage();
+    for (const key of Object.keys(storage)) {
+        if (Array.isArray(storage[key])) {
+            storage[key].length = 0;
+        }
+    }
+}
+/**
+ * Reset the PGlite singleton so a fresh instance is created on next use.
+ */
+async function resetPGliteSingleton() {
+    try {
+        const { PGliteInstance } = require("typeorm-pglite/dist/pglite-instance");
+        await PGliteInstance.close();
+    }
+    catch {
+        // ignore -- singleton may not exist yet
+    }
+}
+/**
+ * Build TypeORM entity classes programmatically from parsed entity definitions.
+ * Uses TypeORM decorators applied at runtime, so no file I/O or compilation needed.
+ *
+ * Clears TypeORM's global metadata storage first to prevent cross-contamination
+ * between runs.
+ */
+function buildEntityClasses(entities) {
+    var _a, _b;
+    clearTypeOrmMetadata();
+    const typeorm = require("typeorm");
+    const classes = [];
+    for (const entityDef of entities) {
+        const className = entityDef.name;
+        const tableName = (0, casing_1.snakeCase)(entityDef.name);
+        const EntityClass = { [className]: class {
+            } }[className];
+        typeorm.Entity(tableName)(EntityClass);
+        const hasCustomPk = (_b = (_a = entityDef.fields) === null || _a === void 0 ? void 0 : _a.some((f) => f.primary)) !== null && _b !== void 0 ? _b : false;
+        const pkType = entityDef.primaryKeyType || "serial";
+        if (!hasCustomPk) {
+            if (pkType === "uuid") {
+                typeorm.PrimaryColumn({ type: "uuid" })(EntityClass.prototype, "id");
+            }
+            else if (pkType === "text") {
+                typeorm.PrimaryColumn({ type: "text" })(EntityClass.prototype, "id");
+            }
+            else {
+                typeorm.PrimaryGeneratedColumn()(EntityClass.prototype, "id");
+            }
+        }
+        if (entityDef.created_at) {
+            typeorm.CreateDateColumn()(EntityClass.prototype, "created_at");
+        }
+        if (entityDef.updated_at) {
+            typeorm.UpdateDateColumn()(EntityClass.prototype, "updated_at");
+        }
+        const fields = entityDef.fields || [];
+        for (const field of fields) {
+            if (!hasCustomPk && field.name === "id")
+                continue;
+            if (entityDef.created_at && field.name === "created_at")
+                continue;
+            if (entityDef.updated_at && field.name === "updated_at")
+                continue;
+            const normalizedType = (0, field_1.normalizeFieldType)(field.type);
+            const colType = field_1.fieldTypeToColumnType[normalizedType] || "varchar";
+            const colOpts = { type: colType };
+            if (field.nullable)
+                colOpts.nullable = true;
+            if (field.unique)
+                colOpts.unique = true;
+            if (field.default !== undefined && field.default !== null) {
+                colOpts.default = field.default;
+            }
+            if (field.type === "enum" && field.values) {
+                colOpts.enum = field.values;
+            }
+            if (field.length)
+                colOpts.length = field.length;
+            if (field.precision)
+                colOpts.precision = field.precision;
+            if (field.scale !== undefined)
+                colOpts.scale = field.scale;
+            if (field.primary) {
+                typeorm.PrimaryColumn(colOpts)(EntityClass.prototype, field.name);
+            }
+            else {
+                typeorm.Column(colOpts)(EntityClass.prototype, field.name);
+            }
+        }
+        classes.push(EntityClass);
+    }
+    return classes;
+}
+/**
+ * Create a TypeORM DataSource configured for PGlite with in-memory entity classes.
+ */
+async function createPGliteDataSource(entityClasses) {
+    const { DataSource } = await Promise.resolve().then(() => tslib_1.__importStar(require("typeorm")));
+    let PGliteDriver;
+    try {
+        const pgliteModule = await Promise.resolve().then(() => tslib_1.__importStar(require("typeorm-pglite")));
+        PGliteDriver = pgliteModule.PGliteDriver;
+    }
+    catch (e) {
+        throw new Error("Migration sandbox requires typeorm-pglite and @electric-sql/pglite.\n" +
+            "Install them with: npm install typeorm @electric-sql/pglite typeorm-pglite\n" +
+            `Original error: ${e instanceof Error ? e.message : e}`);
+    }
+    // Create a driver. typeorm-pglite uses a singleton PGliteInstance
+    // so multiple DataSources share the same in-process database.
+    const _driver = new PGliteDriver();
+    const dataSource = new DataSource({
+        type: "postgres",
+        driver: _driver.driver,
+        entities: entityClasses,
+        synchronize: false,
+        logging: false,
+    });
+    return dataSource;
+}
+/**
+ * Run the migration sandbox: detect changes, generate SQL, test execution.
+ *
+ * Uses PGlite's singleton pattern: all DataSources within a single
+ * runMigrationSandbox call share the same in-process Postgres instance.
+ * We reset the singleton at the start of each run for isolation.
+ */
+async function runMigrationSandbox(current, projectDir) {
+    var _a;
+    const snapshot = (0, snapshot_1.readSnapshot)(projectDir);
+    // Build a comparable representation of current schema for snapshot
+    const currentSnapshot = {
+        entities: current.entities.map((e) => {
+            var _a;
+            return ({
+                name: e.name,
+                fields: (_a = e.fields) === null || _a === void 0 ? void 0 : _a.map((f) => {
+                    var _a;
+                    return ({
+                        name: f.name,
+                        type: f.type,
+                        nullable: f.nullable,
+                        unique: f.unique,
+                        default: (_a = f.default) !== null && _a !== void 0 ? _a : undefined,
+                        index: f.index,
+                    });
+                }),
+                primaryKeyType: e.primaryKeyType,
+                created_at: e.created_at,
+                updated_at: e.updated_at,
+                scopeBy: e.scopeBy,
+            });
+        }),
+    };
+    // Quick check: has anything changed?
+    if (snapshot && !schemaChanged(currentSnapshot, snapshot)) {
+        return {
+            needed: false,
+            success: true,
+            upSql: [],
+            downSql: [],
+        };
+    }
+    try {
+        // Reset PGlite singleton to get a fresh in-memory database
+        await resetPGliteSingleton();
+        // Build previous entities from snapshot
+        const previousEntities = ((_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.entities) === null || _a === void 0 ? void 0 : _a.length)
+            ? snapshot.entities.map((se) => {
+                var _a;
+                return ({
+                    name: se.name,
+                    fields: (_a = se.fields) === null || _a === void 0 ? void 0 : _a.map((f) => ({
+                        name: f.name,
+                        type: f.type,
+                        nullable: f.nullable,
+                        unique: f.unique,
+                        default: f.default,
+                        index: f.index,
+                    })),
+                    primaryKeyType: se.primaryKeyType,
+                    created_at: se.created_at,
+                    updated_at: se.updated_at,
+                    scopeBy: se.scopeBy,
+                });
+            })
+            : [];
+        // Step 1: Establish baseline with previous schema
+        if (previousEntities.length > 0) {
+            const prevClasses = buildEntityClasses(previousEntities);
+            const prevDs = await createPGliteDataSource(prevClasses);
+            await prevDs.initialize();
+            await prevDs.synchronize();
+            // Don't call prevDs.destroy() -- it closes the PGlite singleton.
+            // Just disconnect TypeORM's connection manager.
+            // The PGlite in-memory database persists in the singleton.
+        }
+        // Step 2: Compute diff with current schema
+        const currentClasses = buildEntityClasses(current.entities);
+        const currentDs = await createPGliteDataSource(currentClasses);
+        await currentDs.initialize();
+        try {
+            const sqlInMemory = await currentDs.driver.createSchemaBuilder().log();
+            const upQueries = sqlInMemory.upQueries || [];
+            const downQueries = sqlInMemory.downQueries || [];
+            const upSql = upQueries.map((q) => q.query);
+            const downSql = downQueries.map((q) => q.query);
+            if (upSql.length === 0) {
+                await resetPGliteSingleton();
+                return {
+                    needed: false,
+                    success: true,
+                    upSql: [],
+                    downSql: [],
+                };
+            }
+            // Step 3: Execute the migration to verify it works
+            await currentDs.synchronize();
+            await resetPGliteSingleton();
+            return {
+                needed: true,
+                success: true,
+                upSql,
+                downSql,
+            };
+        }
+        catch (execError) {
+            await resetPGliteSingleton();
+            return {
+                needed: true,
+                success: false,
+                upSql: [],
+                downSql: [],
+                error: execError instanceof Error
+                    ? execError.message
+                    : String(execError),
+            };
+        }
+    }
+    catch (outerError) {
+        try {
+            await resetPGliteSingleton();
+        }
+        catch { /* ignore */ }
+        return {
+            needed: true,
+            success: false,
+            upSql: [],
+            downSql: [],
+            error: outerError instanceof Error
+                ? outerError.message
+                : String(outerError),
+        };
+    }
+}
+exports.runMigrationSandbox = runMigrationSandbox;
+/**
+ * Apply a successful migration: update the snapshot to current state.
+ */
+function applyMigration(current, projectDir) {
+    const snapshot = {
+        entities: current.entities.map((e) => {
+            var _a;
+            return ({
+                name: e.name,
+                fields: (_a = e.fields) === null || _a === void 0 ? void 0 : _a.map((f) => {
+                    var _a;
+                    return ({
+                        name: f.name,
+                        type: f.type,
+                        nullable: f.nullable,
+                        unique: f.unique,
+                        default: (_a = f.default) !== null && _a !== void 0 ? _a : undefined,
+                        index: f.index,
+                    });
+                }),
+                primaryKeyType: e.primaryKeyType,
+                created_at: e.created_at,
+                updated_at: e.updated_at,
+                scopeBy: e.scopeBy,
+            });
+        }),
+    };
+    (0, snapshot_1.writeSnapshot)(snapshot, projectDir);
+}
+exports.applyMigration = applyMigration;
+/**
+ * Reset the sandbox: remove snapshot and PGlite data.
+ */
+function resetSandbox(projectDir) {
+    (0, snapshot_1.resetSnapshot)(projectDir);
+    const dataDir = getSandboxDataDir(projectDir);
+    if (fs.existsSync(dataDir)) {
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+}
+exports.resetSandbox = resetSandbox;
+/**
+ * Simple deep comparison between current and snapshot schemas.
+ */
+function schemaChanged(current, snapshot) {
+    return (JSON.stringify(current.entities) !== JSON.stringify(snapshot.entities));
+}

package/dist/lib/migrate/snapshot.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Schema Snapshot Manager
+ *
+ * Manages the schema snapshot at .apso/sandbox/schema-snapshot.json.
+ * The snapshot stores the .apsorc content at the time of last successful migration.
+ * Comparing current .apsorc against the snapshot detects whether a migration is needed.
+ */
+/**
+ * Shape of the stored snapshot (mirrors the parsed .apsorc structure)
+ */
+export interface ApsorcSnapshot {
+    entities: Array<{
+        name: string;
+        fields?: Array<{
+            name: string;
+            type: string;
+            nullable?: boolean;
+            unique?: boolean;
+            default?: unknown;
+            index?: boolean;
+        }>;
+        primaryKeyType?: string;
+        created_at?: boolean;
+        updated_at?: boolean;
+        scopeBy?: string | string[];
+    }>;
+    relationships?: Array<{
+        from: string;
+        to: string;
+        type: string;
+        to_name?: string;
+        nullable?: boolean;
+        bi_directional?: boolean;
+        cascadeDelete?: boolean;
+    }>;
+    version?: number;
+    rootFolder?: string;
+    apiType?: string;
+}
+/**
+ * Subset of ParsedApsorc we use for comparison.
+ * Avoids importing the full ParsedApsorc type which carries runtime-only data (relationshipMap).
+ */
+export interface ComparableSchema {
+    entities: Array<{
+        name: string;
+        fields?: Array<{
+            name: string;
+            type: string;
+            nullable?: boolean;
+            unique?: boolean;
+            default?: unknown;
+            index?: boolean;
+        }>;
+        primaryKeyType?: string;
+        created_at?: boolean;
+        updated_at?: boolean;
+        scopeBy?: string | string[];
+    }>;
+}
+/**
+ * Read the saved schema snapshot, or null if none exists.
+ */
+export declare function readSnapshot(projectDir?: string): ApsorcSnapshot | null;
+/**
+ * Write a schema snapshot to disk.
+ */
+export declare function writeSnapshot(schema: ApsorcSnapshot, projectDir?: string): void;
+/**
+ * Delete the snapshot and sandbox directory contents (for --reset).
+ */
+export declare function resetSnapshot(projectDir?: string): void;
+/**
+ * Detect whether the current schema differs from the stored snapshot.
+ *
+ * Compares entity names, field definitions, and relationships using
+ * deterministic JSON serialization. Returns true if any change is detected,
+ * or if no snapshot exists (first run).
+ */
+export declare function hasChanges(current: ComparableSchema, snapshot: ApsorcSnapshot | null): boolean;

package/dist/lib/migrate/snapshot.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Schema Snapshot Manager
+ *
+ * Manages the schema snapshot at .apso/sandbox/schema-snapshot.json.
+ * The snapshot stores the .apsorc content at the time of last successful migration.
+ * Comparing current .apsorc against the snapshot detects whether a migration is needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasChanges = exports.resetSnapshot = exports.writeSnapshot = exports.readSnapshot = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const paths_1 = require("../config/paths");
+function getSandboxDir(projectDir) {
+    return path.join((0, paths_1.getProjectConfigDir)(projectDir), "sandbox");
+}
+function getSnapshotPath(projectDir) {
+    return path.join(getSandboxDir(projectDir), "schema-snapshot.json");
+}
+/**
+ * Read the saved schema snapshot, or null if none exists.
+ */
+function readSnapshot(projectDir) {
+    const snapshotPath = getSnapshotPath(projectDir);
+    if (!fs.existsSync(snapshotPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(snapshotPath, "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+exports.readSnapshot = readSnapshot;
+/**
+ * Write a schema snapshot to disk.
+ */
+function writeSnapshot(schema, projectDir) {
+    const sandboxDir = getSandboxDir(projectDir);
+    (0, paths_1.ensureDir)(sandboxDir);
+    const snapshotPath = getSnapshotPath(projectDir);
+    fs.writeFileSync(snapshotPath, JSON.stringify(schema, null, 2), "utf-8");
+}
+exports.writeSnapshot = writeSnapshot;
+/**
+ * Delete the snapshot and sandbox directory contents (for --reset).
+ */
+function resetSnapshot(projectDir) {
+    const sandboxDir = getSandboxDir(projectDir);
+    if (fs.existsSync(sandboxDir)) {
+        fs.rmSync(sandboxDir, { recursive: true, force: true });
+    }
+}
+exports.resetSnapshot = resetSnapshot;
+/**
+ * Detect whether the current schema differs from the stored snapshot.
+ *
+ * Compares entity names, field definitions, and relationships using
+ * deterministic JSON serialization. Returns true if any change is detected,
+ * or if no snapshot exists (first run).
+ */
+function hasChanges(current, snapshot) {
+    if (!snapshot) {
+        return true;
+    }
+    const normalize = (obj) => JSON.stringify(obj);
+    // Compare entity count
+    if (current.entities.length !== snapshot.entities.length) {
+        return true;
+    }
+    // Build maps for comparison
+    const currentMap = new Map(current.entities.map((e) => [e.name, e]));
+    const snapshotMap = new Map(snapshot.entities.map((e) => [e.name, e]));
+    // Check for added or removed entities
+    for (const name of currentMap.keys()) {
+        if (!snapshotMap.has(name)) {
+            return true;
+        }
+    }
+    for (const name of snapshotMap.keys()) {
+        if (!currentMap.has(name)) {
+            return true;
+        }
+    }
+    // Deep compare each entity
+    for (const [name, currentEntity] of currentMap) {
+        const snapshotEntity = snapshotMap.get(name);
+        if (!snapshotEntity) {
+            return true;
+        }
+        if (normalize(currentEntity) !== normalize(snapshotEntity)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasChanges = hasChanges;

package/dist/lib/templates/entities/entity-col-enum.eta

@@ -3,10 +3,10 @@
 @Column({
     type: 'enum',
     enum: enums.<%= field.dataType%>,
-    default: enums.<%= field.dataType%>.<%= field.default %>
+    default: enums.<%= field.dataType%>.<%= field.default.toLowerCase().replace(/[^a-z0-9]/g, '_').replace(/^(\d)/, '_$1').replace(/_+/g, '_').replace(/_$/, '') %>
 })
 <% if (field.index ) {%>
 @Index()
 <% } %>
 
-<%= field.name %>!: enums.<%= field.dataType%>;
+<%= field.name %>!: enums.<%= field.dataType%>;

package/dist/lib/templates/python/models/model-col-datetime.eta

@@ -1,5 +1,5 @@
     <%= it.field.name %>: Mapped[<% if (it.field.nullable !== false) { %>Optional[datetime]<% } else { %>datetime<% } %>] = mapped_column(
         DateTime,
         nullable=<%= it.field.nullable === false ? 'False' : 'True' %><% if (it.field.default !== undefined && it.field.default !== null) { %>,
-        default=<%~ it.field.default === null ? 'None' : JSON.stringify(it.field.default) %><% } %>
+        default=<%= it.field.default === null ? 'None' : `"${it.field.default}"` %><% } %>
     )

package/dist/lib/templates/python/models/model-col-string.eta

@@ -2,5 +2,5 @@
         String(<%= it.field.length || 255 %>),
         nullable=<%= it.field.nullable === false ? 'False' : 'True' %><% if (it.field.unique) { %>,
         unique=True<% } %><% if (it.field.default !== undefined && it.field.default !== null) { %>,
-        default=<%~ JSON.stringify(it.field.default) %><% } %>
+        default="<%= it.field.default %>"<% } %>
     )

package/dist/lib/templates/python/models/model-col-text.eta

@@ -2,5 +2,5 @@
         Text,
         nullable=<%= it.field.nullable === false ? 'False' : 'True' %><% if (it.field.unique) { %>,
         unique=True<% } %><% if (it.field.default !== undefined && it.field.default !== null) { %>,
-        default=<%~ JSON.stringify(it.field.default) %><% } %>
+        default="<%= it.field.default %>"<% } %>
     )

package/dist/lib/templates/python/models/model-col-varchar.eta

@@ -2,5 +2,5 @@
         String(<%= it.field.length || 255 %>),
         nullable=<%= it.field.nullable === false ? 'False' : 'True' %><% if (it.field.unique) { %>,
         unique=True<% } %><% if (it.field.default !== undefined && it.field.default !== null) { %>,
-        default=<%~ JSON.stringify(it.field.default) %><% } %>
+        default="<%= it.field.default %>"<% } %>
     )

package/dist/lib/utils/field.d.ts

@@ -1,4 +1,16 @@
 import { FieldType, Field, ComputedField, Entity } from "../types";
+/**
+ * Canonical mapping from .apsorc field types to Postgres column types.
+ * This is the single source of truth -- sandbox, entity-generator, and
+ * templates should all derive from this map.
+ */
+export declare const fieldTypeToColumnType: Record<string, string>;
+/**
+ * Normalize a field type to its template-compatible name.
+ * PostgreSQL has some types with spaces (e.g., "double precision")
+ * that need to be mapped to simpler names for template lookup.
+ */
+export declare const normalizeFieldType: (type: string) => string;
 export declare const getJsTypeFromFieldType: (type: FieldType | string) => string;
 export declare const getDefaultValueForField: (field: Field) => string | null;
 export declare const getFieldForTemplate: (fields: Field[], entityName: string) => ComputedField[];

package/dist/lib/utils/field.js

@@ -1,7 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDecimalField = exports.typeExistsInEntity = exports.fieldToEnumType = exports.getFieldForTemplate = exports.getDefaultValueForField = exports.getJsTypeFromFieldType = void 0;
+exports.validateDecimalField = exports.typeExistsInEntity = exports.fieldToEnumType = exports.getFieldForTemplate = exports.getDefaultValueForField = exports.getJsTypeFromFieldType = exports.normalizeFieldType = exports.fieldTypeToColumnType = void 0;
 const casing_1 = require("./casing");
+/**
+ * Canonical mapping from .apsorc field types to Postgres column types.
+ * This is the single source of truth -- sandbox, entity-generator, and
+ * templates should all derive from this map.
+ */
+exports.fieldTypeToColumnType = {
+    text: "text",
+    string: "varchar",
+    varchar: "varchar",
+    char: "char",
+    boolean: "boolean",
+    integer: "integer",
+    int: "integer",
+    smallint: "smallint",
+    bigint: "bigint",
+    float: "float",
+    real: "real",
+    double: "double precision",
+    decimal: "decimal",
+    numeric: "numeric",
+    serial: "integer",
+    bigserial: "bigint",
+    smallserial: "smallint",
+    date: "date",
+    timestamp: "timestamp",
+    timestamptz: "timestamptz",
+    time: "time",
+    timetz: "timetz",
+    json: "json",
+    jsonb: "jsonb",
+    "json-plain": "json",
+    uuid: "uuid",
+    money: "money",
+    bytea: "bytea",
+    xml: "xml",
+    inet: "inet",
+    interval: "interval",
+    tsvector: "tsvector",
+    enum: "enum",
+    array: "text",
+    point: "point",
+    geometry: "geometry",
+    geography: "geography",
+    linestring: "geometry",
+    polygon: "geometry",
+    multipoint: "geometry",
+    multilinestring: "geometry",
+    multipolygon: "geometry",
+    geometrycollection: "geometry",
+    int4range: "int4range",
+};
+/**
+ * Normalize PostgreSQL field types that have spaces or variants to their
+ * template-compatible names. This ensures field types like "double precision"
+ * map to the corresponding template file (entity-col-double.eta).
+ */
+const fieldTypeNormalizationMap = {
+    "double precision": "double",
+    "character varying": "varchar",
+    "bit varying": "varbit",
+    "time without time zone": "time",
+    "time with time zone": "timetz",
+    "timestamp without time zone": "timestamp",
+    "timestamp with time zone": "timestamptz",
+};
+/**
+ * Normalize a field type to its template-compatible name.
+ * PostgreSQL has some types with spaces (e.g., "double precision")
+ * that need to be mapped to simpler names for template lookup.
+ */
+const normalizeFieldType = (type) => {
+    return fieldTypeNormalizationMap[type.toLowerCase()] || type;
+};
+exports.normalizeFieldType = normalizeFieldType;
 const typeToJsType = {
     array: "string[]",
     boolean: "boolean",
@@ -9,6 +83,7 @@ const typeToJsType = {
     float: "number",
     real: "number",
     double: "number",
+    "double precision": "number",
     decimal: "number",
     numeric: "number",
     smallint: "number",
@@ -82,8 +157,12 @@ exports.getDefaultValueForField = getDefaultValueForField;
 const getFieldForTemplate = (fields, entityName) => fields.map((field) => {
     // Validate decimal/numeric fields
     (0, exports.validateDecimalField)(field);
+    // Normalize field type for template lookup (e.g., "double precision" -> "double")
+    const normalizedType = (0, exports.normalizeFieldType)(field.type);
     return {
         ...field,
+        // Use normalized type for template lookup
+        type: normalizedType,
         default: (0, exports.getDefaultValueForField)(field),
         dataType: field.type === "enum"
             ? (0, exports.fieldToEnumType)(field.name, entityName)