@deterministic-code/datasources-mysql 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/MysqlAlterTableStatementRenderer.d.ts

@@ -1,5 +1,6 @@
 import { AlterTableStatementTextRenderer, type AlterAction, type Column, type NotNull } from "@deterministic-code/datasources";
 export declare class MysqlAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected quote(name: string): string;
     protected typeName(column: Column): string;
     protected columnDefault(column: Column): string;
     protected notNullSql(value?: NotNull): string;

package/dist/MysqlAlterTableStatementRenderer.js

@@ -1,11 +1,14 @@
 import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
-import { columnTypes } from "./columnTypes.js";
+import { MysqlDriver } from "./MysqlDriver.js";
 export class MysqlAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    quote(name) {
+        return MysqlDriver.quote(name);
+    }
     typeName(column) {
-        return columnTypes[column.type] ?? column.type;
+        return MysqlDriver.nativeType(column);
     }
     columnDefault(column) {
-        return column.default == null ? "" : ` DEFAULT ${column.default.value}`;
+        return column.default == null ? "" : ` DEFAULT ${MysqlDriver.nativeDefault(column)}`;
     }
     notNullSql(value) {
         return value == null ? "" : " NOT NULL";

package/dist/MysqlCreateTableStatementRenderer.d.ts

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

package/dist/MysqlCreateTableStatementRenderer.js

@@ -1,11 +1,14 @@
 import { CreateTableStatementTextRenderer } from "@deterministic-code/datasources";
-import { columnTypes } from "./columnTypes.js";
+import { MysqlDriver } from "./MysqlDriver.js";
 export class MysqlCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    quote(name) {
+        return MysqlDriver.quote(name);
+    }
     typeName(column) {
-        return columnTypes[column.type] ?? column.type;
+        return MysqlDriver.nativeType(column);
     }
     columnDefault(column) {
-        return column.default == null ? "" : ` DEFAULT ${column.default.value}`;
+        return column.default == null ? "" : ` DEFAULT ${MysqlDriver.nativeDefault(column)}`;
     }
     notNullSql(value) {
         return value == null ? "" : " NOT NULL";

package/dist/MysqlCreateTriggerStatementRenderer.js

@@ -1,7 +1,8 @@
 import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+import { MysqlDriver } from "./MysqlDriver.js";
 export class MysqlCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
     render(statement) {
-        return `CREATE TRIGGER ${statement.name} BEFORE UPDATE ON ${statement.table}
-FOR EACH ROW SET NEW.${statement.updatedColumn} = ${statement.utcNow}`;
+        return `CREATE TRIGGER ${MysqlDriver.quote(statement.name)} BEFORE UPDATE ON ${MysqlDriver.quote(statement.table)}
+FOR EACH ROW SET NEW.${MysqlDriver.quote(statement.updatedColumn)} = ${MysqlDriver.utcNow()}`;
     }
 }

package/dist/MysqlDriver.d.ts

@@ -1,13 +1,22 @@
-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 MysqlDriver implements IDriver {
+    static readonly procedurePayloadType = "JSON";
+    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;
     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/MysqlDriver.js

@@ -1,13 +1,59 @@
-import { DatasourceError, DefaultValueConverter, sqlStringLiteral, DeterministicTypeConverter, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { DatasourceError, StatementTextRenderer, } from "@deterministic-code/datasources";
 import { MysqlConnection } from "./connection.js";
 import { MysqlCommand } from "./command.js";
 import { MysqlTransaction } from "./transaction.js";
 import { MysqlRowTypeConverters } from "./converters/MysqlRowTypeConverters.js";
 import { MysqlStatementRenderer } from "./MysqlStatementRenderer.js";
 import { columnTypes } from "./columnTypes.js";
+import { applyKeywords } from "./applyKeywords.js";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter, sqlStringLiteral } from "./DefaultValueConverter.js";
 export { columnTypes };
-const statements = new StatementTextRenderer(t => new MysqlStatementRenderer(t));
+const statements = new StatementTextRenderer(t => new MysqlStatementRenderer(t), undefined, undefined, undefined, applyKeywords);
+const types = new TypeMap({
+    string: "TEXT",
+    character: "CHAR(1)",
+    integer: "INT",
+    unsignedinteger: "INT UNSIGNED",
+    smallinteger: "SMALLINT",
+    unsignedsmallinteger: "SMALLINT UNSIGNED",
+    biginteger: "BIGINT",
+    unsignedbiginteger: "BIGINT UNSIGNED",
+    float: "DOUBLE",
+    decimal: "DECIMAL(10, 2)",
+    boolean: "TINYINT(1)",
+    datetime: "DATETIME(3)",
+    binary: "BLOB",
+    uuid: "CHAR(36)",
+    reference: "INT",
+});
+const defaults = new DefaultValueConverter({
+    newId: () => `(UUID())`,
+    now: () => `(NOW(3))`,
+    utcNow: () => `(UTC_TIMESTAMP(3))`,
+    booleanOn: "1",
+    booleanOff: "0",
+    hex: (arg) => `(X'${arg}')`,
+    hexReverse: /^(?:\(X'(.*)'\)|X'(.*)')$/,
+    quote: (arg) => `(${sqlStringLiteral(arg)})`,
+    quoteReverse: /^(?:\('(.*)'\)|'(.*)')$/,
+});
 export class MysqlDriver {
+    static procedurePayloadType = "JSON";
+    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"
+        ? MysqlDriver.procedurePayloadType
+        : parameter.field
+            ? types.convertField(parameter.field)
+            : types.dictionary[parameter.type] ?? parameter.type;
     statementRenderer = statements;
     information = {
         descriptions: [
@@ -31,42 +77,8 @@ export class MysqlDriver {
     rowTypeConverters = MysqlRowTypeConverters;
     quoteLeft = "`";
     quoteRight = "`";
-    typeConverter = new DeterministicTypeConverter({
-        string: "TEXT",
-        character: "CHAR(1)",
-        integer: "INT",
-        unsignedinteger: "INT UNSIGNED",
-        smallinteger: "SMALLINT",
-        unsignedsmallinteger: "SMALLINT UNSIGNED",
-        biginteger: "BIGINT",
-        unsignedbiginteger: "BIGINT UNSIGNED",
-        float: "DOUBLE",
-        decimal: "DECIMAL(10, 2)",
-        boolean: "TINYINT(1)",
-        datetime: "DATETIME(3)",
-        binary: "BLOB",
-        uuid: "CHAR(36)",
-        reference: "INT",
-    }, {
-        dialectName: "mysql",
-        stringUnlimited: "TEXT",
-        stringSized: (n) => (n <= 16383 ? `VARCHAR(${n})` : "LONGTEXT"),
-        character: "CHAR",
-        decimal: { kind: "optional", type: "DECIMAL", fallback: "DECIMAL(10, 2)" },
-        binaryUnlimited: "BLOB",
-        binarySized: (n) => (n <= 65535 ? `VARBINARY(${n})` : "LONGBLOB"),
-    });
-    defaultValueConverter = new DefaultValueConverter({
-        newId: () => `(UUID())`,
-        now: () => `(NOW(3))`,
-        utcNow: () => `(UTC_TIMESTAMP(3))`,
-        booleanOn: "1",
-        booleanOff: "0",
-        hex: (arg) => `(X'${arg}')`,
-        hexReverse: /^(?:\(X'(.*)'\)|X'(.*)')$/,
-        quote: (arg) => `(${sqlStringLiteral(arg)})`,
-        quoteReverse: /^(?:\('(.*)'\)|'(.*)')$/,
-    });
+    typeConverter = types;
+    defaultValueConverter = defaults;
     columnType = (name) => columnTypes[name] ??
         (() => {
             throw new DatasourceError(`Unknown mysql type "${name}"`);

package/dist/MysqlDropIndexStatementRenderer.js

@@ -1,6 +1,7 @@
 import { DropIndexStatementTextRenderer } from "@deterministic-code/datasources";
+import { MysqlDriver } from "./MysqlDriver.js";
 export class MysqlDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
     render(statement) {
-        return `DROP INDEX ${statement.name} ON ${statement.table}`;
+        return `DROP INDEX ${MysqlDriver.quote(statement.name)} ON ${MysqlDriver.quote(statement.table)}`;
     }
 }

package/dist/MysqlQuotedRenderers.d.ts

@@ -0,0 +1,10 @@
+import { CreateIndexStatementTextRenderer, DropTableStatementTextRenderer, type ForeignKeyStatement } from "@deterministic-code/datasources";
+export declare class MysqlDropTableStatementRenderer extends DropTableStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class MysqlCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class MysqlForeignKeyStatementRenderer {
+    render(statement: ForeignKeyStatement): string;
+}

package/dist/MysqlQuotedRenderers.js

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

package/dist/MysqlSqlSeedStatementRenderer.d.ts

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

package/dist/MysqlSqlSeedStatementRenderer.js

@@ -0,0 +1,49 @@
+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 "(UTC_TIMESTAMP(3))";
+    if (type === "datetime" && text === "Now")
+        return "(NOW(3))";
+    if (type === "uuid" && text === "NewId")
+        return "(UUID())";
+    if (type === "boolean")
+        return text === "true" || text === "True" ? "1" : "0";
+    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) ? "1" : "0";
+    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 MysqlSqlSeedStatementRenderer {
+    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(", ");
+        return `INSERT INTO ${table} (${cols}) VALUES (${values})`;
+    }
+}

package/dist/MysqlStatementRenderer.d.ts

@@ -1,6 +1,7 @@
-import { AlterTableStatement, BulkUpdateStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropRoutineStatement, 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, ForeignKeyStatement, type ProcedureSource, SelectInsertedIdStatement, SqlSeedStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
 export declare class MysqlStatementRenderer 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;
@@ -16,4 +17,8 @@ export declare class MysqlStatementRenderer 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 visitForeignKey(key: ForeignKeyStatement): string;
 }

package/dist/MysqlStatementRenderer.js

@@ -1,4 +1,4 @@
-import { SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
+import { sqlProcedureStatementsOf, SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
 import { MysqlAlterTableStatementRenderer } from "./MysqlAlterTableStatementRenderer.js";
 import { MysqlBulkUpdateStatementTextRenderer } from "./MysqlBulkUpdateStatementTextRenderer.js";
 import { MysqlCreateTableStatementRenderer } from "./MysqlCreateTableStatementRenderer.js";
@@ -6,6 +6,8 @@ import { MysqlCreateTriggerStatementRenderer } from "./MysqlCreateTriggerStateme
 import { MysqlDropIndexStatementRenderer } from "./MysqlDropIndexStatementRenderer.js";
 import { MysqlDropRoutineStatementRenderer } from "./MysqlDropRoutineStatementRenderer.js";
 import { MysqlStoredProcedureStatementRenderer } from "./MysqlStoredProcedureStatementRenderer.js";
+import { MysqlSqlSeedStatementRenderer } from "./MysqlSqlSeedStatementRenderer.js";
+import { MysqlCreateIndexStatementRenderer, MysqlDropTableStatementRenderer, MysqlForeignKeyStatementRenderer, } from "./MysqlQuotedRenderers.js";
 class MysqlSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
     render(statement) {
         return `SELECT LAST_INSERT_ID() AS ${statement.column}`;
@@ -15,6 +17,9 @@ export class MysqlStatementRenderer extends StatementRenderer {
     constructor(text) {
         super(text);
     }
+    procedures(source) {
+        return sqlProcedureStatementsOf(source);
+    }
     visitSelectInsertedId(inserted) {
         return new MysqlSelectInsertedIdStatementTextRenderer().render(inserted);
     }
@@ -60,4 +65,16 @@ export class MysqlStatementRenderer extends StatementRenderer {
     visitCreateBulkDeleteStoredProcedureStatement(statement) {
         return new MysqlStoredProcedureStatementRenderer().renderBulkDelete(statement);
     }
+    visitSqlSeed(seed) {
+        return new MysqlSqlSeedStatementRenderer().render(seed);
+    }
+    visitDropTable(drop) {
+        return new MysqlDropTableStatementRenderer().render(drop);
+    }
+    visitCreateIndex(index) {
+        return new MysqlCreateIndexStatementRenderer().render(index);
+    }
+    visitForeignKey(key) {
+        return new MysqlForeignKeyStatementRenderer().render(key);
+    }
 }

package/dist/MysqlStoredProcedureStatementRenderer.js

@@ -1,7 +1,9 @@
 import { DefaultStatementTextRenderer } from "@deterministic-code/datasources";
-const params = (list) => list.map((p) => `  IN ${p.name} ${p.type}`).join(",\n");
+import { MysqlDriver } from "./MysqlDriver.js";
+const typeOf = (parameter) => MysqlDriver.nativeParam(parameter);
+const params = (list) => list.map((p) => `  IN ${p.name} ${typeOf(p)}`).join(",\n");
 const where = (columns) => columns.map((c) => `t.${c} = ${c}`).join(" AND ");
-const jsonColumns = (columns) => columns.map((c) => `${c.name} ${c.type} PATH '$.${c.name}'`).join(", ");
+const jsonColumns = (columns) => columns.map((c) => `${c.name} ${typeOf(c)} PATH '$.${c.name}'`).join(", ");
 const procedure = (name, signature, body) => `DROP PROCEDURE IF EXISTS ${name};
 GO
 CREATE PROCEDURE ${name}(${signature})
@@ -19,10 +21,10 @@ export class MysqlStoredProcedureStatementRenderer {
         const body = generated
             ? `  DECLARE new_id VARCHAR(36);
   SET new_id = UUID();
-  INSERT INTO ${statement.table} (${insertCols.join(", ")})
+  INSERT INTO ${MysqlDriver.quote(statement.table)} (${insertCols.join(", ")})
   VALUES (${vals.join(", ")});
   SELECT new_id AS ${statement.key};`
-            : `  INSERT INTO ${statement.table} (${insertCols.join(", ")})
+            : `  INSERT INTO ${MysqlDriver.quote(statement.table)} (${insertCols.join(", ")})
   VALUES (${vals.join(", ")});
   SELECT LAST_INSERT_ID() AS ${statement.key};`;
         return procedure(statement.name, `\n${params(statement.parameters)}\n`, body);
@@ -30,22 +32,22 @@ export class MysqlStoredProcedureStatementRenderer {
     renderNestedRead(statement) {
         const select = DefaultStatementTextRenderer.instance.render(statement.select);
         const signature = statement.arguments
-            .map((argument) => `IN ${argument.parameter.name} ${argument.parameter.type}`)
+            .map((argument) => `IN ${argument.parameter.name} ${typeOf(argument.parameter)}`)
             .join(", ");
         return procedure(statement.name, signature, `  ${select};`);
     }
     renderRead(statement) {
         const aliased = statement.columns.map((c) => `t.${c}`).join(", ");
         if (statement.byProperties.length === 0) {
-            return procedure(statement.name, "", `  SELECT ${aliased} FROM ${statement.table} t ORDER BY t.${statement.key};`);
+            return procedure(statement.name, "", `  SELECT ${aliased} FROM ${MysqlDriver.quote(statement.table)} t ORDER BY t.${statement.key};`);
         }
         const signature = statement.byProperties
             .map((c) => {
-            const type = statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType;
+            const type = typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType });
             return `IN ${c} ${type}`;
         })
             .join(", ");
-        return procedure(statement.name, signature, `  SELECT ${aliased} FROM ${statement.table} t WHERE ${where(statement.byProperties)};`);
+        return procedure(statement.name, signature, `  SELECT ${aliased} FROM ${MysqlDriver.quote(statement.table)} t WHERE ${where(statement.byProperties)};`);
     }
     renderUpdate(statement) {
         const sets = statement.writable.map((c) => `    t.${c}     = ${c}`);
@@ -55,7 +57,7 @@ export class MysqlStoredProcedureStatementRenderer {
                 sets.push(`    t.${statement.auditUpdated} = ${auditParam.name}`);
         }
         const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
-        return procedure(statement.name, `\n${params(statement.parameters)}\n`, `  UPDATE ${statement.table} t
+        return procedure(statement.name, `\n${params(statement.parameters)}\n`, `  UPDATE ${MysqlDriver.quote(statement.table)} t
   SET
 ${sets.join(",\n")}
   WHERE ${where(by)};
@@ -65,16 +67,16 @@ ${sets.join(",\n")}
         const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
         const signature = by
             .map((c) => {
-            const type = statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType;
+            const type = typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType });
             return `IN ${c} ${type}`;
         })
             .join(", ");
-        return procedure(statement.name, signature, `  DELETE t FROM ${statement.table} t WHERE ${where(by)};
+        return procedure(statement.name, signature, `  DELETE t FROM ${MysqlDriver.quote(statement.table)} t WHERE ${where(by)};
   SELECT ROW_COUNT() AS affected;`);
     }
     renderBulkCreate(statement) {
         const cols = statement.columns.map((c) => c.name).join(", ");
-        return procedure(statement.name, `IN ${statement.payload.name} ${statement.payload.type}, OUT ids JSON`, `  INSERT INTO ${statement.table} (${cols})
+        return procedure(statement.name, `IN ${statement.payload.name} ${typeOf(statement.payload)}, OUT ids JSON`, `  INSERT INTO ${MysqlDriver.quote(statement.table)} (${cols})
   SELECT ${cols}
   FROM JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (
     ${jsonColumns(statement.columns)}
@@ -93,7 +95,7 @@ ${sets.join(",\n")}
             .filter((c) => c.name !== statement.key)
             .map((c) => `c.${c.name} = payload_rows.${c.name}`)
             .join(", ");
-        return procedure(statement.name, `IN ${statement.payload.name} ${statement.payload.type}`, `  UPDATE ${statement.table} c
+        return procedure(statement.name, `IN ${statement.payload.name} ${typeOf(statement.payload)}`, `  UPDATE ${MysqlDriver.quote(statement.table)} c
   JOIN JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (
     ${jsonColumns(statement.columns)}
   )) AS payload_rows ON c.${statement.key} = payload_rows.${statement.key}
@@ -104,6 +106,6 @@ ${sets.join(",\n")}
             name: statement.key,
             type: statement.keyType,
         };
-        return procedure(statement.name, `IN ${statement.payload.name} ${statement.payload.type}`, `  DELETE c FROM ${statement.table} c JOIN JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (${key.name} ${key.type} PATH '$.${key.name}')) AS payload_rows ON c.${statement.key} = payload_rows.${statement.key};`);
+        return procedure(statement.name, `IN ${statement.payload.name} ${typeOf(statement.payload)}`, `  DELETE c FROM ${MysqlDriver.quote(statement.table)} c JOIN JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (${key.name} ${typeOf(key)} PATH '$.${key.name}')) AS payload_rows ON c.${statement.key} = payload_rows.${statement.key};`);
     }
 }

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,43 @@
+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"
+                : Number(field.size) <= 16383
+                    ? `VARCHAR(${field.size})`
+                    : "LONGTEXT";
+        if (field.type === "character")
+            return `CHAR(${field.size == null ? 1 : Number(field.size)})`;
+        if (field.type === "decimal") {
+            if (field.size == null)
+                return "DECIMAL(10, 2)";
+            if (Array.isArray(field.size) && field.size.length === 2)
+                return `DECIMAL(${field.size[0]}, ${field.size[1]})`;
+            throw new Error(`decimal field "${field.name}" size must be [precision, scale] tuple; got ${field.size}`);
+        }
+        if (field.type === "binary")
+            return field.size == null || field.size === "unlimited"
+                ? "BLOB"
+                : Number(field.size) <= 65535
+                    ? `VARBINARY(${field.size})`
+                    : "LONGBLOB";
+        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,13 @@
+const KEYWORDS = new Set([
+    "AFTER", "ALTER", "AND", "AS", "AUTO_INCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BIGINT",
+    "BLOB", "BOOLEAN", "BY", "CASCADE", "CAST", "CHAR", "CONSTRAINT", "CREATE", "DATETIME",
+    "DECIMAL", "DECLARE", "DEFAULT", "DELETE", "DOUBLE", "DROP", "EACH", "ELSE", "END",
+    "EXISTS", "FALSE", "FLOAT", "FOR", "FOREIGN", "FROM", "GENERATED", "IF", "IN", "INDEX",
+    "INNER", "INSERT", "INT", "INTEGER", "INTO", "JOIN", "KEY", "LAST_INSERT_ID", "LONGBLOB",
+    "LONGTEXT", "NOT", "NOW", "NULL", "NUMERIC", "ON", "OR", "ORDER", "PRIMARY", "PROCEDURE",
+    "REFERENCES", "REPLACE", "RETURN", "ROW", "ROW_COUNT", "SELECT", "SET", "SMALLINT", "TABLE",
+    "TEXT", "THEN", "TIMESTAMP", "TINYINT", "TRIGGER", "TRUE", "UNIQUE", "UNSIGNED", "UPDATE",
+    "UTC_TIMESTAMP", "VALUES", "VARBINARY", "VARCHAR", "WHEN", "WHERE",
+]);
+const TOKEN = /('(?:''|[^'])*')|(`(?:``|[^`])*`)|("(?:""|[^"])*")|(--[^\n]*)|(\/\*[\s\S]*?\*\/)|(?<word>[A-Za-z_][A-Za-z0-9_]*)/g;
+export const applyKeywords = (sql, keyword) => sql.replace(TOKEN, (match, _s, _b, _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-mysql",
-  "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",
     "mysql2": "^3.14.0"
   }
 }