@deterministic-code/datasources-postgres 0.1.18 → 0.1.30

package/dist/DefaultValueConverter.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultValueOptions } from "./DefaultValueOptions.js";
+export declare const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+export type SpecToken = {
+    spec: RegExp;
+    specText?: (arg: string) => string;
+};
+export type DefaultEntry = SpecToken & {
+    native: (arg: string) => string;
+    reverse: RegExp;
+};
+type DefaultToken = {
+    token: string;
+    arg?: string | boolean;
+};
+export declare const sqlStringLiteral: (value: string | number | boolean | null | undefined) => string;
+export declare class DefaultValueConverter {
+    static readonly spec: Record<string, Record<string, SpecToken>>;
+    readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+    constructor(options: DefaultValueOptions);
+    static parse(specType: string, value: unknown): DefaultToken;
+    convert: (specType: string, text: string) => string | null;
+    reverseConvert: (specType: string, native: string) => string;
+    private static dictionaryOf;
+}
+export {};

package/dist/DefaultValueConverter.js

@@ -0,0 +1,172 @@
+export const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+const NUMERIC_TYPES = [
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+];
+const NUMERIC_LITERAL_TYPES = new Set([...NUMERIC_TYPES, "reference"]);
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+const quotedReverse = /^'(.*)'$/;
+const identity = (arg) => arg;
+const intLit = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit = { spec: /^[0-9]+$/, specText: identity };
+const floatLit = { spec: /^-?[0-9]+(\.[0-9]+)?$/, specText: identity };
+export const sqlStringLiteral = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const exact = (text) => new RegExp(`^${escapeRe(text)}$`);
+const quoted = (arg) => sqlStringLiteral(arg);
+const callTokenName = (name) => (name === "uuid" ? "Uuid" : name);
+const token = (specToken, native, reverse) => ({
+    ...specToken,
+    native,
+    reverse,
+});
+export class DefaultValueConverter {
+    static spec = {
+        string: { String: { spec: /^.*$/, specText: identity } },
+        character: { String: { spec: /^.+$/, specText: identity } },
+        integer: { Numeric: intLit },
+        unsignedinteger: { Numeric: uintLit },
+        smallinteger: { Numeric: intLit },
+        unsignedsmallinteger: { Numeric: uintLit },
+        biginteger: { Numeric: intLit },
+        unsignedbiginteger: { Numeric: uintLit },
+        float: { Numeric: floatLit },
+        decimal: { Numeric: floatLit, String: { spec: /^.*$/, specText: identity } },
+        boolean: { Boolean: { spec: /^(true|false)$/, specText: identity } },
+        datetime: {
+            Now: { spec: /^Now$/ },
+            UtcNow: { spec: /^UtcNow$/ },
+            DateTime: {
+                spec: /^DateTime\('[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|[+-][0-9]{2}:[0-9]{2})'\)$/,
+                specText: (arg) => `DateTime('${arg}')`,
+            },
+        },
+        binary: {
+            Hex: { spec: /^Hex\('([0-9a-fA-F]{2})*'\)$/, specText: (arg) => `Hex('${arg}')` },
+        },
+        uuid: {
+            NewId: { spec: /^NewId$/ },
+            Empty: { spec: /^Empty$/ },
+            Uuid: {
+                spec: /^uuid\('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'\)$/,
+                specText: (arg) => `uuid('${arg}')`,
+            },
+        },
+        reference: {},
+    };
+    dictionary;
+    constructor(options) {
+        this.dictionary = DefaultValueConverter.dictionaryOf(options);
+    }
+    static parse(specType, value) {
+        if (value === undefined || value === null)
+            return { token: "None" };
+        const v = String(value);
+        const call = CALL_FORM.exec(v);
+        if (call !== null)
+            return { token: callTokenName(call[1]), arg: call[2] };
+        if (specType === "boolean") {
+            return { token: "Boolean", arg: typeof value === "boolean" ? value : v === "true" };
+        }
+        if (NUMERIC_LITERAL_TYPES.has(specType))
+            return { token: "Numeric", arg: v };
+        if (specType === "datetime") {
+            if (v === "Now")
+                return { token: "Now" };
+            if (v === "UtcNow")
+                return { token: "UtcNow" };
+            return { token: "DateTime", arg: v };
+        }
+        if (specType === "uuid") {
+            if (v === "NewId")
+                return { token: "NewId" };
+            if (v === "Empty")
+                return { token: "Empty" };
+            return { token: "Uuid", arg: v };
+        }
+        if (specType === "binary")
+            return { token: "Hex", arg: v };
+        return { token: "String", arg: v };
+    }
+    convert = (specType, text) => {
+        const parsed = DefaultValueConverter.parse(specType, text);
+        if (parsed.token === "None")
+            return null;
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        const entry = entries[parsed.token];
+        if (entry === undefined)
+            return null;
+        if (!entry.spec.test(text)) {
+            throw new Error(`default_value '${text}' is not a valid ${specType} ${parsed.token} default`);
+        }
+        const expr = entry.native(parsed.arg === undefined ? "" : String(parsed.arg));
+        return expr === "" ? null : expr;
+    };
+    reverseConvert = (specType, native) => {
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        for (const [name, entry] of Object.entries(entries)) {
+            const match = entry.reverse.exec(native);
+            if (match === null)
+                continue;
+            const arg = match.slice(1).find((group) => group !== undefined) ?? "";
+            return entry.specText === undefined ? name : entry.specText(arg);
+        }
+        throw new Error(`Native default '${native}' is not a valid ${specType} default`);
+    };
+    static dictionaryOf = (opts) => {
+        const spec = DefaultValueConverter.spec;
+        const newId = opts.newId();
+        const now = opts.now();
+        const utcNow = opts.utcNow();
+        const numericEntries = (type) => {
+            const numeric = spec[type].Numeric;
+            return {
+                Numeric: token(numeric, (arg) => arg, numeric.spec),
+                String: token(numeric, (arg) => arg, numeric.spec),
+            };
+        };
+        const quote = opts.quote ?? quoted;
+        const quoteReverse = opts.quoteReverse ?? quotedReverse;
+        const quotedString = {
+            String: token(spec.string.String, quote, quoteReverse),
+            Numeric: token(spec.string.String, quote, quoteReverse),
+        };
+        const dictionary = {
+            string: quotedString,
+            character: {
+                String: token(spec.character.String, quote, quoteReverse),
+                Numeric: token(spec.character.String, quote, quoteReverse),
+            },
+            boolean: {
+                Boolean: token(spec.boolean.Boolean, (arg) => (arg === "true" ? opts.booleanOn : opts.booleanOff), new RegExp(`^(${escapeRe(opts.booleanOn)}|${escapeRe(opts.booleanOff)})$`)),
+            },
+            datetime: {
+                Now: token(spec.datetime.Now, () => now, exact(now)),
+                UtcNow: token(spec.datetime.UtcNow, () => utcNow, exact(utcNow)),
+                DateTime: token(spec.datetime.DateTime, quoted, quotedReverse),
+            },
+            binary: {
+                Hex: token(spec.binary.Hex, opts.hex, opts.hexReverse),
+            },
+            uuid: {
+                NewId: token(spec.uuid.NewId, () => newId, exact(newId)),
+                Empty: token(spec.uuid.Empty, () => quoted(EMPTY_UUID), exact(quoted(EMPTY_UUID))),
+                Uuid: token(spec.uuid.Uuid, quoted, quotedReverse),
+            },
+            reference: {},
+        };
+        for (const type of NUMERIC_TYPES)
+            dictionary[type] = numericEntries(type);
+        return dictionary;
+    };
+}

package/dist/DefaultValueOptions.d.ts

@@ -0,0 +1,11 @@
+export type DefaultValueOptions = {
+    newId: () => string;
+    now: () => string;
+    utcNow: () => string;
+    booleanOn: string;
+    booleanOff: string;
+    hex: (arg: string) => string;
+    hexReverse: RegExp;
+    quote?: (arg: string) => string;
+    quoteReverse?: RegExp;
+};

package/dist/DefaultValueOptions.js

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

package/dist/PostgresAlterTableStatementRenderer.d.ts

@@ -1,6 +1,8 @@
 import { AlterTableStatementTextRenderer, type AlterAction, type Column } from "@deterministic-code/datasources";
 export declare class PostgresAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected quote(name: string): string;
     protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
     protected actionSql(action: AlterAction): string;
     private postgresAlter;
 }

package/dist/PostgresAlterTableStatementRenderer.js

@@ -1,8 +1,18 @@
 import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
-import { columnTypes } from "./columnTypes.js";
+import { PostgresDriver } from "./PostgresDriver.js";
 export class PostgresAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    quote(name) {
+        return PostgresDriver.quote(name);
+    }
     typeName(column) {
-        return columnTypes[column.type] ?? column.type;
+        return PostgresDriver.nativeType(column);
+    }
+    columnDefault(column) {
+        return column.default == null
+            ? ""
+            : column.default.name == null
+                ? ` DEFAULT ${PostgresDriver.nativeDefault(column)}`
+                : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${PostgresDriver.nativeDefault(column)}`;
     }
     actionSql(action) {
         return action.kind === "alterColumn" ? this.postgresAlter(action.column) : super.actionSql(action);
@@ -11,7 +21,7 @@ export class PostgresAlterTableStatementRenderer extends AlterTableStatementText
         const name = this.quote(column.name);
         const defaultSql = column.default == null
             ? `ALTER COLUMN ${name} DROP DEFAULT`
-            : `ALTER COLUMN ${name} SET DEFAULT ${column.default.value}`;
+            : `ALTER COLUMN ${name} SET DEFAULT ${PostgresDriver.nativeDefault(column)}`;
         const nullSql = column.notNull == null
             ? `ALTER COLUMN ${name} DROP NOT NULL`
             : `ALTER COLUMN ${name} SET NOT NULL`;

package/dist/PostgresCreateTableStatementRenderer.d.ts

@@ -1,5 +1,6 @@
 import { CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
 export declare class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    protected quote(name: string): string;
     protected typeName(column: Column): string;
     protected columnDefault(column: Column): string;
     protected identity(column: Column): string;

package/dist/PostgresCreateTableStatementRenderer.js

@@ -1,16 +1,21 @@
 import { ColumnDefault, CreateTableStatementTextRenderer, } from "@deterministic-code/datasources";
 import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.js";
-import { columnTypes } from "./columnTypes.js";
+import { PostgresDriver } from "./PostgresDriver.js";
 export class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    quote(name) {
+        return PostgresDriver.quote(name);
+    }
     typeName(column) {
-        return columnTypes[column.type] ?? column.type;
+        return PostgresDriver.nativeType(column);
     }
     columnDefault(column) {
         const literal = sqlLiteral(column);
         const value = column.default;
-        return value == null || literal == null
-            ? super.columnDefault(column)
-            : super.columnDefault({ ...column, default: new ColumnDefault(literal, value.name) });
+        if (value == null)
+            return "";
+        if (literal != null)
+            return super.columnDefault({ ...column, default: new ColumnDefault(literal, value.name) });
+        return super.columnDefault({ ...column, default: new ColumnDefault(PostgresDriver.nativeDefault(column), value.name) });
     }
     identity(column) {
         return column.identity ? " GENERATED BY DEFAULT AS IDENTITY" : "";

package/dist/PostgresCreateTriggerStatementRenderer.js

@@ -1,13 +1,15 @@
 import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+import { PostgresDriver } from "./PostgresDriver.js";
 export class PostgresCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
     render(statement) {
+        const updated = PostgresDriver.quote(statement.updatedColumn);
         return `-- Shared updated_at function
 CREATE OR REPLACE FUNCTION set_updated_at() RETURNS TRIGGER AS $$
 BEGIN
-  NEW.${statement.updatedColumn} = NOW() AT TIME ZONE 'UTC';
+  NEW.${updated} = ${PostgresDriver.utcNow()};
   RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
-CREATE TRIGGER ${statement.name} BEFORE UPDATE ON ${statement.table} FOR EACH ROW EXECUTE FUNCTION set_updated_at()`;
+CREATE TRIGGER ${PostgresDriver.quote(statement.name)} BEFORE UPDATE ON ${PostgresDriver.quote(statement.table)} FOR EACH ROW EXECUTE FUNCTION set_updated_at()`;
     }
 }

package/dist/PostgresDriver.d.ts

@@ -1,13 +1,23 @@
-import { DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+import { StatementTextRenderer, type Cell, type Column, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type RoutineParameter, type TypeConverter } from "@deterministic-code/datasources";
 import { columnTypes } from "./columnTypes.js";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter } from "./DefaultValueConverter.js";
 export { columnTypes };
 export declare class PostgresDriver implements IDriver {
+    static readonly procedurePayloadType = "jsonb";
+    static applyKeywords: (sql: string, keyword: (word: string) => string) => string;
+    static quote: (name: string) => string;
+    static nativeType: (column: Column) => string;
+    static nativeDefault: (column: Column) => string;
+    static utcNow: () => string;
+    static nativeParam: (parameter: RoutineParameter) => string;
+    static nativeSpec: (spec: string) => string;
     readonly statementRenderer: StatementTextRenderer;
     readonly information: Information;
     rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
     readonly quoteLeft = "\"";
     readonly quoteRight = "\"";
-    readonly typeConverter: DeterministicTypeConverter;
+    readonly typeConverter: TypeMap;
     readonly defaultValueConverter: DefaultValueConverter;
     columnType: (name: string) => string;
     connection: (options?: DatasourceOptions) => IConnection;

package/dist/PostgresDriver.js

@@ -1,13 +1,58 @@
-import { DatasourceError, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { DatasourceError, StatementTextRenderer, } from "@deterministic-code/datasources";
 import { PostgresConnection } from "./connection.js";
 import { PostgresCommand } from "./command.js";
 import { PostgresTransaction } from "./transaction.js";
 import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.js";
 import { PostgresStatementRenderer } from "./PostgresStatementRenderer.js";
 import { columnTypes } from "./columnTypes.js";
+import { applyKeywords } from "./applyKeywords.js";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter } from "./DefaultValueConverter.js";
 export { columnTypes };
-const statements = new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+const statements = new StatementTextRenderer(t => new PostgresStatementRenderer(t), undefined, undefined, undefined, applyKeywords);
+const types = new TypeMap({
+    string: "TEXT",
+    character: "CHAR(1)",
+    integer: "INTEGER",
+    unsignedinteger: "BIGINT",
+    smallinteger: "SMALLINT",
+    unsignedsmallinteger: "INTEGER",
+    biginteger: "BIGINT",
+    unsignedbiginteger: "NUMERIC(20)",
+    float: "DOUBLE PRECISION",
+    decimal: "NUMERIC",
+    boolean: "BOOLEAN",
+    datetime: "TIMESTAMPTZ",
+    binary: "BYTEA",
+    uuid: "UUID",
+    reference: "INTEGER",
+});
+const defaults = new DefaultValueConverter({
+    newId: () => "gen_random_uuid()",
+    now: () => "LOCALTIMESTAMP",
+    utcNow: () => `(NOW() AT TIME ZONE 'UTC')`,
+    booleanOn: "TRUE",
+    booleanOff: "FALSE",
+    hex: (arg) => `'\\x${arg}'`,
+    hexReverse: /^'\\x(.*)'$/,
+});
 export class PostgresDriver {
+    static procedurePayloadType = "jsonb";
+    static applyKeywords = applyKeywords;
+    static quote = (name) => `"${name}"`;
+    static nativeType = (column) => column.field ? types.convertField(column.field) : columnTypes[column.type] ?? column.type;
+    static nativeDefault = (column) => column.default == null
+        ? ""
+        : column.field === undefined
+            ? column.default.value
+            : defaults.convert(column.field.type, column.default.value) ?? column.default.value;
+    static utcNow = () => defaults.convert("datetime", "UtcNow") ?? "";
+    static nativeParam = (parameter) => parameter.type === "payload"
+        ? PostgresDriver.procedurePayloadType
+        : parameter.field
+            ? types.convertField(parameter.field)
+            : types.dictionary[parameter.type] ?? parameter.type;
+    static nativeSpec = (spec) => spec === "payload" ? PostgresDriver.procedurePayloadType : types.dictionary[spec] ?? spec;
     statementRenderer = statements;
     information = {
         descriptions: [
@@ -32,38 +77,8 @@ export class PostgresDriver {
     rowTypeConverters = PostgresRowTypeConverters;
     quoteLeft = '"';
     quoteRight = '"';
-    typeConverter = new DeterministicTypeConverter({
-        string: "TEXT",
-        character: "CHAR(1)",
-        integer: "INTEGER",
-        unsignedinteger: "BIGINT",
-        smallinteger: "SMALLINT",
-        unsignedsmallinteger: "INTEGER",
-        biginteger: "BIGINT",
-        unsignedbiginteger: "NUMERIC(20)",
-        float: "DOUBLE PRECISION",
-        decimal: "NUMERIC",
-        boolean: "BOOLEAN",
-        datetime: "TIMESTAMPTZ",
-        binary: "BYTEA",
-        uuid: "UUID",
-        reference: "INTEGER",
-    }, {
-        dialectName: "postgres",
-        stringUnlimited: "TEXT",
-        stringSized: (n) => `VARCHAR(${n})`,
-        character: "CHAR",
-        decimal: { kind: "optional", type: "NUMERIC", fallback: "NUMERIC" },
-    });
-    defaultValueConverter = new DefaultValueConverter({
-        newId: () => "gen_random_uuid()",
-        now: () => "LOCALTIMESTAMP",
-        utcNow: () => `(NOW() AT TIME ZONE 'UTC')`,
-        booleanOn: "TRUE",
-        booleanOff: "FALSE",
-        hex: (arg) => `'\\x${arg}'`,
-        hexReverse: /^'\\x(.*)'$/,
-    });
+    typeConverter = types;
+    defaultValueConverter = defaults;
     columnType = (name) => columnTypes[name] ??
         (() => {
             throw new DatasourceError(`Unknown postgres type "${name}"`);

package/dist/PostgresDropTriggerStatementRenderer.js

@@ -1,6 +1,7 @@
 import { DropTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+import { PostgresDriver } from "./PostgresDriver.js";
 export class PostgresDropTriggerStatementRenderer extends DropTriggerStatementTextRenderer {
     render(statement) {
-        return `DROP TRIGGER IF EXISTS ${statement.name} ON ${statement.table}`;
+        return `DROP TRIGGER IF EXISTS ${PostgresDriver.quote(statement.name)} ON ${PostgresDriver.quote(statement.table)}`;
     }
 }

package/dist/PostgresQuotedRenderers.d.ts

@@ -0,0 +1,13 @@
+import { CreateIndexStatementTextRenderer, DropIndexStatementTextRenderer, DropTableStatementTextRenderer, type ForeignKeyStatement } from "@deterministic-code/datasources";
+export declare class PostgresDropTableStatementRenderer extends DropTableStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class PostgresCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class PostgresDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class PostgresForeignKeyStatementRenderer {
+    render(statement: ForeignKeyStatement): string;
+}

package/dist/PostgresQuotedRenderers.js

@@ -0,0 +1,28 @@
+import { CreateIndexStatementTextRenderer, DropIndexStatementTextRenderer, DropTableStatementTextRenderer, } from "@deterministic-code/datasources";
+import { PostgresDriver } from "./PostgresDriver.js";
+export class PostgresDropTableStatementRenderer extends DropTableStatementTextRenderer {
+    quote(name) {
+        return PostgresDriver.quote(name);
+    }
+}
+export class PostgresCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    quote(name) {
+        return PostgresDriver.quote(name);
+    }
+}
+export class PostgresDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
+    quote(name) {
+        return PostgresDriver.quote(name);
+    }
+}
+export class PostgresForeignKeyStatementRenderer {
+    render(statement) {
+        const table = PostgresDriver.quote(statement.table);
+        const name = PostgresDriver.quote(statement.name);
+        if (statement.kind === "drop")
+            return `ALTER TABLE ${table} DROP CONSTRAINT ${name}`;
+        const cols = statement.columns.map(PostgresDriver.quote).join(", ");
+        const refs = statement.referencesColumns.map(PostgresDriver.quote).join(", ");
+        return `ALTER TABLE ${table} ADD CONSTRAINT ${name} FOREIGN KEY (${cols}) REFERENCES ${PostgresDriver.quote(statement.referencesTable)} (${refs})`;
+    }
+}

package/dist/PostgresSqlSeedStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { SqlSeedStatement } from "@deterministic-code/datasources";
+export declare class PostgresSqlSeedStatementRenderer {
+    render(statement: SqlSeedStatement): string;
+}

package/dist/PostgresSqlSeedStatementRenderer.js

@@ -0,0 +1,53 @@
+const quote = (ident) => `"${ident}"`;
+const quoteString = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const truthy = (value) => value === true || value === "true" || value === "True" || value === 1;
+const numeric = new Set([
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "reference",
+    "float",
+    "decimal",
+]);
+const defaultSql = (type, def) => {
+    const text = String(def);
+    if (type === "datetime" && text === "UtcNow")
+        return "(NOW() AT TIME ZONE 'UTC')";
+    if (type === "datetime" && text === "Now")
+        return "LOCALTIMESTAMP";
+    if (type === "uuid" && text === "NewId")
+        return "gen_random_uuid()";
+    if (type === "boolean")
+        return text === "true" || text === "True" ? "TRUE" : "FALSE";
+    return quoteString(text);
+};
+const literal = (column) => {
+    if (column.value == null)
+        return column.field.defaultValue != null ? defaultSql(column.field.type, column.field.defaultValue) : "NULL";
+    if (column.field.type === "boolean")
+        return truthy(column.value) ? "TRUE" : "FALSE";
+    if (numeric.has(column.field.type))
+        return String(column.value);
+    if (column.field.type === "binary")
+        return `'\\x${column.value}'`;
+    return quoteString(column.value);
+};
+export class PostgresSqlSeedStatementRenderer {
+    render(statement) {
+        const table = quote(statement.table);
+        if (statement.kind === "delete") {
+            const key = statement.columns[0];
+            return `DELETE FROM ${table} WHERE ${quote(key.column)} = ${literal(key)}`;
+        }
+        const cols = statement.columns.map((c) => quote(c.column)).join(", ");
+        const values = statement.columns.map(literal).join(", ");
+        const insert = `INSERT INTO ${table} (${cols}) VALUES (${values})`;
+        if (!statement.identity || statement.idColumn == null)
+            return insert;
+        const id = statement.idColumn;
+        return `${insert};\nSELECT setval(pg_get_serial_sequence('${statement.table}', '${id}'), (SELECT MAX(${quote(id)}) FROM ${table}))`;
+    }
+}

package/dist/PostgresStatementRenderer.d.ts

@@ -1,6 +1,7 @@
-import { AlterTableStatement, BulkUpdateStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropRoutineStatement, DropTriggerStatement, IdentityInsertStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+import { AlterTableStatement, BulkUpdateStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, CreateIndexStatement, DropIndexStatement, DropRoutineStatement, DropTableStatement, DropTriggerStatement, ForeignKeyStatement, IdentityInsertStatement, type ProcedureSource, SelectInsertedIdStatement, SqlSeedStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
 export declare class PostgresStatementRenderer extends StatementRenderer {
     constructor(text: StatementTextRenderer);
+    procedures(source: ProcedureSource): import("@deterministic-code/datasources").IStatement[];
     protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
     protected visitCreateTable(create: CreateTableStatement): string;
     protected visitAlterTable(alter: AlterTableStatement): string;
@@ -17,4 +18,9 @@ export declare class PostgresStatementRenderer extends StatementRenderer {
     protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
     protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
     protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+    protected visitSqlSeed(seed: SqlSeedStatement): string;
+    protected visitDropTable(drop: DropTableStatement): string;
+    protected visitCreateIndex(index: CreateIndexStatement): string;
+    protected visitDropIndex(index: DropIndexStatement): string;
+    protected visitForeignKey(key: ForeignKeyStatement): string;
 }

package/dist/PostgresStatementRenderer.js

@@ -1,4 +1,4 @@
-import { SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
+import { sqlProcedureStatementsOf, SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
 import { PostgresAlterTableStatementRenderer } from "./PostgresAlterTableStatementRenderer.js";
 import { PostgresBulkUpdateStatementTextRenderer } from "./PostgresBulkUpdateStatementTextRenderer.js";
 import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.js";
@@ -7,6 +7,8 @@ import { PostgresDropRoutineStatementRenderer } from "./PostgresDropRoutineState
 import { PostgresStoredProcedureStatementRenderer } from "./PostgresStoredProcedureStatementRenderer.js";
 import { PostgresDropTriggerStatementRenderer } from "./PostgresDropTriggerStatementRenderer.js";
 import { PostgresIdentityInsertStatementRenderer } from "./PostgresIdentityInsertStatementRenderer.js";
+import { PostgresSqlSeedStatementRenderer } from "./PostgresSqlSeedStatementRenderer.js";
+import { PostgresCreateIndexStatementRenderer, PostgresDropIndexStatementRenderer, PostgresDropTableStatementRenderer, PostgresForeignKeyStatementRenderer, } from "./PostgresQuotedRenderers.js";
 class PostgresSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
     render(statement) {
         const { table, column } = statement;
@@ -17,6 +19,9 @@ export class PostgresStatementRenderer extends StatementRenderer {
     constructor(text) {
         super(text);
     }
+    procedures(source) {
+        return sqlProcedureStatementsOf(source);
+    }
     visitSelectInsertedId(inserted) {
         return new PostgresSelectInsertedIdStatementTextRenderer().render(inserted);
     }
@@ -65,4 +70,19 @@ export class PostgresStatementRenderer extends StatementRenderer {
     visitCreateBulkDeleteStoredProcedureStatement(statement) {
         return new PostgresStoredProcedureStatementRenderer().renderBulkDelete(statement);
     }
+    visitSqlSeed(seed) {
+        return new PostgresSqlSeedStatementRenderer().render(seed);
+    }
+    visitDropTable(drop) {
+        return new PostgresDropTableStatementRenderer().render(drop);
+    }
+    visitCreateIndex(index) {
+        return new PostgresCreateIndexStatementRenderer().render(index);
+    }
+    visitDropIndex(index) {
+        return new PostgresDropIndexStatementRenderer().render(index);
+    }
+    visitForeignKey(key) {
+        return new PostgresForeignKeyStatementRenderer().render(key);
+    }
 }

package/dist/PostgresStoredProcedureStatementRenderer.js

@@ -1,13 +1,15 @@
 import { DefaultStatementTextRenderer } from "@deterministic-code/datasources";
-const params = (list) => list.map((p) => `  ${p.name} ${p.type}`).join(",\n");
-const recordset = (columns) => columns.map((c) => `${c.name} ${c.type}`).join(", ");
+import { PostgresDriver } from "./PostgresDriver.js";
+const typeOf = (parameter) => PostgresDriver.nativeParam(parameter);
+const params = (list) => list.map((p) => `  ${p.name} ${typeOf(p)}`).join(",\n");
+const recordset = (columns) => columns.map((c) => `${c.name} ${typeOf(c)}`).join(", ");
 export class PostgresStoredProcedureStatementRenderer {
     renderCreate(statement) {
         return `CREATE OR REPLACE FUNCTION ${statement.name}(
 ${params(statement.parameters)}
-) RETURNS ${statement.keyType} LANGUAGE plpgsql AS $$
+) RETURNS ${PostgresDriver.nativeSpec(statement.keyType)} LANGUAGE plpgsql AS $$
 DECLARE
-  new_id ${statement.keyType};
+  new_id ${PostgresDriver.nativeSpec(statement.keyType)};
 BEGIN
   INSERT INTO ${statement.table} (${statement.parameters.map((p) => p.name).join(", ")})
   VALUES (${statement.parameters.map((p) => p.name).join(", ")})
@@ -19,7 +21,7 @@ $$`;
     renderNestedRead(statement) {
         const select = DefaultStatementTextRenderer.instance.render(statement.select);
         const signature = statement.arguments
-            .map((argument) => `${argument.parameter.name} ${argument.parameter.type}`)
+            .map((argument) => `${argument.parameter.name} ${typeOf(argument.parameter)}`)
             .join(", ");
         return `CREATE OR REPLACE FUNCTION ${statement.name}(${signature}) RETURNS SETOF RECORD
 LANGUAGE sql AS $$ ${select}; $$`;
@@ -31,7 +33,7 @@ LANGUAGE sql AS $$ ${select}; $$`;
 LANGUAGE sql AS $$ SELECT ${aliased} FROM ${statement.table} t ORDER BY t.${statement.key}; $$`;
         }
         const signature = statement.byProperties
-            .map((c) => `${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .map((c) => `${c} ${typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType })}`)
             .join(", ");
         const pred = statement.byProperties
             .map((c) => `t.${c} = ${statement.name}.${c}`)
@@ -66,7 +68,7 @@ $$`;
     renderDelete(statement) {
         const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
         const signature = by
-            .map((c) => `${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .map((c) => `${c} ${typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType })}`)
             .join(", ");
         const pred = by.map((c) => `t.${c} = ${statement.name}.${c}`).join(" AND ");
         return `CREATE OR REPLACE FUNCTION ${statement.name}(${signature}) RETURNS INT LANGUAGE plpgsql AS $$
@@ -113,7 +115,7 @@ $$`;
         return `CREATE OR REPLACE PROCEDURE ${statement.name}(${statement.payload.name} jsonb)
 LANGUAGE plpgsql AS $$
 BEGIN
-  DELETE FROM ${statement.table} WHERE ${statement.key} IN (SELECT ${statement.key} FROM jsonb_to_recordset(${statement.payload.name}) AS x(${statement.key} ${statement.keyType}));
+  DELETE FROM ${statement.table} WHERE ${statement.key} IN (SELECT ${statement.key} FROM jsonb_to_recordset(${statement.payload.name}) AS x(${statement.key} ${PostgresDriver.nativeSpec(statement.keyType)}));
 END;
 $$`;
     }

package/dist/TypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { IMapping, SpecField } from "@deterministic-code/datasources";
+export declare class TypeMap implements IMapping<string, string> {
+    readonly dictionary: Record<string, string>;
+    private readonly reverse;
+    constructor(dictionary: Record<string, string>);
+    convert: (from: string) => string;
+    convertField: (field: SpecField) => string;
+    reverseConvert: (native: string) => string;
+}

package/dist/TypeMap.js

@@ -0,0 +1,33 @@
+export class TypeMap {
+    dictionary;
+    reverse = new Map();
+    constructor(dictionary) {
+        this.dictionary = dictionary;
+        for (const [spec, native] of Object.entries(dictionary)) {
+            if (!this.reverse.has(native))
+                this.reverse.set(native, spec);
+        }
+    }
+    convert = (from) => this.dictionary[from] ??
+        (() => {
+            throw new Error(`Unknown spec field type: ${from}`);
+        })();
+    convertField = (field) => {
+        if (field.type === "string")
+            return field.size == null || field.size === "unlimited" ? "TEXT" : `VARCHAR(${field.size})`;
+        if (field.type === "character")
+            return `CHAR(${field.size == null ? 1 : Number(field.size)})`;
+        if (field.type === "decimal") {
+            if (field.size == null)
+                return "NUMERIC";
+            if (Array.isArray(field.size) && field.size.length === 2)
+                return `NUMERIC(${field.size[0]}, ${field.size[1]})`;
+            throw new Error(`decimal field "${field.name}" size must be [precision, scale] tuple; got ${field.size}`);
+        }
+        return this.convert(field.type);
+    };
+    reverseConvert = (native) => this.reverse.get(native) ??
+        (() => {
+            throw new Error(`Unknown native field type: ${native}`);
+        })();
+}

package/dist/applyKeywords.d.ts

@@ -0,0 +1 @@
+export declare const applyKeywords: (sql: string, keyword: (word: string) => string) => string;

package/dist/applyKeywords.js

@@ -0,0 +1,14 @@
+const KEYWORDS = new Set([
+    "AFTER", "ALTER", "AND", "AS", "AT", "BEFORE", "BEGIN", "BETWEEN", "BIGINT", "BIGSERIAL",
+    "BOOLEAN", "BY", "BYTEA", "CASCADE", "CAST", "CHAR", "CONSTRAINT", "CREATE", "DECIMAL",
+    "DECLARE", "DEFAULT", "DELETE", "DIAGNOSTICS", "DOUBLE", "DROP", "EACH", "ELSE", "END",
+    "EXCEPTION", "EXECUTE", "EXISTS", "FALSE", "FLOAT", "FOR", "FOREIGN", "FROM", "FUNCTION",
+    "GENERATED", "GET", "IF", "IMMEDIATE", "IN", "INDEX", "INNER", "INSERT", "INT", "INTEGER",
+    "INTO", "JOIN", "KEY", "LANGUAGE", "NEW", "NOT", "NOW", "NULL", "NUMERIC", "OLD", "ON", "OR",
+    "ORDER", "OTHERS", "PRECISION", "PRIMARY", "PROCEDURE", "RAISE", "REAL", "REFERENCES",
+    "REPLACE", "RETURN", "RETURNING", "RETURNS", "ROW", "ROW_COUNT", "SELECT", "SERIAL", "SET",
+    "SETOF", "SMALLINT", "SQLCODE", "TABLE", "TEXT", "THEN", "TIME", "TIMESTAMP", "TIMESTAMPTZ",
+    "TRIGGER", "TRUE", "UNIQUE", "UPDATE", "UUID", "VALUES", "VARCHAR", "WHEN", "WHERE", "ZONE",
+]);
+const TOKEN = /('(?:''|[^'])*')|("(?:""|[^"])*")|(--[^\n]*)|(\/\*[\s\S]*?\*\/)|(?<word>[A-Za-z_][A-Za-z0-9_]*)/g;
+export const applyKeywords = (sql, keyword) => sql.replace(TOKEN, (match, _s, _d, _lc, _bc, word) => word !== undefined && KEYWORDS.has(word.toUpperCase()) ? keyword(word) : match);

package/dist/procedureSpecs.d.ts

@@ -0,0 +1,10 @@
+export type ProcOp = "create" | "read" | "update" | "delete" | "bulkCreate" | "bulkUpdate" | "bulkDelete";
+export type ProcSpec = {
+    op: ProcOp;
+    name: string;
+    byProperties: string[];
+};
+export declare const procedureSpecs: (entityName: string, byGroups: string[][], casing: {
+    routineName: (stem: string) => string;
+    pluralStem: (entity: string) => string;
+}) => ProcSpec[];

package/dist/procedureSpecs.js

@@ -0,0 +1,17 @@
+export const procedureSpecs = (entityName, byGroups, casing) => {
+    const name = (stem) => casing.routineName(stem);
+    const plural = casing.pluralStem(entityName);
+    const bySuffix = (props) => props.length === 0 ? "" : `_by_${props.join("_")}`;
+    return [
+        { op: "create", name: name(`create_${plural}`), byProperties: [] },
+        { op: "read", name: name(`read_${plural}`), byProperties: [] },
+        ...byGroups.flatMap((props) => [
+            { op: "read", name: name(`read_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "update", name: name(`update_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "delete", name: name(`delete_${plural}${bySuffix(props)}`), byProperties: props },
+        ]),
+        { op: "bulkCreate", name: name(`bulk_create_${plural}`), byProperties: [] },
+        { op: "bulkUpdate", name: name(`bulk_update_${plural}`), byProperties: [] },
+        { op: "bulkDelete", name: name(`bulk_delete_${plural}`), byProperties: [] },
+    ];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-postgres",
-  "version": "0.1.18",
+  "version": "0.1.30",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -18,7 +18,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.18",
+    "@deterministic-code/datasources": "^0.1.30",
     "@types/pg": "^8.15.5",
     "pg": "^8.16.0",
     "pg-query-stream": "^4.17.0"