dynalitics 0.0.0-stage → 0.1.0

package/dist/dialect/common.d.ts

@@ -0,0 +1,54 @@
+import { type TableRef } from '../model/identifiers.js';
+import type { ColumnDef, ColumnModel, Dialect } from '../model/types.js';
+import type { CompiledQuery, ReadSyntax, Row, SqlDialect } from './types.js';
+export declare const PLACEHOLDER_ROLE: RegExp;
+declare const UNLIMITED: number;
+/** Everything that differs between dialects. The generic builder below turns this into a SqlDialect. */
+export interface DialectSyntax {
+    readonly name: Dialect;
+    readonly limits: SqlDialect['limits'];
+    readonly open: string;
+    readonly close: string;
+    readonly explicitNull: boolean;
+    readonly read: ReadSyntax;
+    placeholder(index: number): string;
+    jsonCast?(placeholder: string): string;
+    timestampParam(d: Date): string;
+    columnType(c: ColumnDef): string;
+    /** Full definition for the id column, constraints included. */
+    idDefinition: string;
+    /** Collation clause that goes right after the type ('' if none). */
+    collation(c: ColumnDef): string;
+    /** Constraint that goes after nullability, e.g. SQL Server's ISJSON check ('' if none). */
+    constraint(c: ColumnDef, model: ColumnModel): string;
+    tableSuffix(): string;
+    tableConstraints(model: ColumnModel, quote: (n: string) => string): readonly string[];
+    addColumnKeyword: string;
+    dropNotNull(table: string, name: string, type: string): string;
+    alterType(table: string, name: string, type: string): string;
+    supportsPartialIndex: boolean;
+    introspectSql(table: TableRef, q: (n: string) => string): CompiledQuery;
+    privilegeSql(table: TableRef, qualified: string): readonly CompiledQuery[];
+    parsePrivileges(results: readonly (readonly Row[])[], table: TableRef): ReadonlySet<string>;
+    grantTarget(table: TableRef, q: (n: string) => string): string;
+    grantSelectColumns(target: string, columns: readonly string[], role: string, q: (n: string) => string): string;
+    renderRole(role: string, q: (n: string) => string): string;
+    grantPreamble(table: TableRef, writer: string, reader: string, q: (n: string) => string): readonly string[];
+}
+export declare function indexName(table: string, suffix: string, max: number): string;
+interface IndexSpec {
+    readonly suffix: string;
+    readonly columns: readonly string[];
+    readonly whereNotNull?: string;
+}
+/** Recommended indexes (spec 6.3): range scans, and the "any earlier row?" probes of read-time first-visit. */
+export declare function indexSpecs(model: ColumnModel): readonly IndexSpec[];
+export declare const qualify: (t: TableRef, q: (n: string) => string) => string;
+export declare function createDialect(s: DialectSyntax): SqlDialect;
+/** Shared role rendering: placeholders like <writer_role> pass through, real names must be valid identifiers. */
+export declare function renderRoleWith(role: string, wrap: (name: string) => string): string;
+export { UNLIMITED };
+/** Guards for the few non-identifier values that are inlined into read SQL. */
+export declare function assertLimit(n: number): number;
+export declare function assertJsonKey(key: string): string;
+//# sourceMappingURL=common.d.ts.map

package/dist/dialect/common.js

@@ -0,0 +1,197 @@
+import { createHash } from 'node:crypto';
+import { DynaliticsConfigError } from '../errors.js';
+import { assertIdentifier, isCustomKey, isIdentifier, } from '../model/identifiers.js';
+import { isIntegerColumn } from '../model/physical.js';
+export const PLACEHOLDER_ROLE = /^<[a-z_]+>$/;
+const UNLIMITED = Number.MAX_SAFE_INTEGER;
+const toBool = (v) => v === true || v === 1 || v === '1' || v === 't' || v === 'YES';
+const toNum = (v) => v === null || v === undefined || v === '' ? null : Number.isFinite(Number(v)) ? Number(v) : null;
+function describeComment(c) {
+    if (c.role === 'isFirstVisit')
+        return '-- derived from personal identifiers; NULL without consent';
+    if (c.role === 'custom')
+        return '-- declared custom fields; personal ones are NULL without consent';
+    if (c.role === 'ip')
+        return '-- PERSONAL DATA (stored per ip.mode)';
+    return c.personal ? '-- PERSONAL DATA' : '';
+}
+export function indexName(table, suffix, max) {
+    const full = `${table}_${suffix}`;
+    if (full.length <= max)
+        return full;
+    const digest = createHash('sha1').update(full).digest('hex').slice(0, 8);
+    return `${full.slice(0, max - 9)}_${digest}`;
+}
+/** Recommended indexes (spec 6.3): range scans, and the "any earlier row?" probes of read-time first-visit. */
+export function indexSpecs(model) {
+    const ts = model.columns.find((c) => c.role === 'timestamp');
+    const id = model.columns.find((c) => c.role === 'id');
+    if (ts === undefined)
+        return [];
+    const specs = [
+        { suffix: 'visited_at_idx', columns: id === undefined ? [ts.name] : [ts.name, id.name] },
+    ];
+    const { userId, ip } = model.identity;
+    if (userId !== undefined) {
+        specs.push({
+            suffix: 'user_id_idx',
+            columns: [userId.name, ts.name],
+            whereNotNull: userId.name,
+        });
+    }
+    if (ip !== undefined)
+        specs.push({ suffix: 'ip_idx', columns: [ip.name, ts.name], whereNotNull: ip.name });
+    return specs;
+}
+export const qualify = (t, q) => [t.database, t.schema, t.name]
+    .filter((p) => p !== undefined)
+    .map(q)
+    .join('.');
+export function createDialect(s) {
+    const quoteIdent = (name) => {
+        assertIdentifier(name, 'identifier');
+        return `${s.open}${name}${s.close}`;
+    };
+    const qualifiedTable = (t) => [t.database, t.schema, t.name]
+        .filter((p) => p !== undefined)
+        .map(quoteIdent)
+        .join('.');
+    const columnType = (c) => s.columnType(c);
+    const columnDefinition = (c, model) => {
+        if (c.type.kind === 'id')
+            return s.idDefinition;
+        const nullPart = c.nullable ? (s.explicitNull ? 'NULL' : '') : 'NOT NULL';
+        return [`${columnType(c)} ${s.collation(c)}`.trim(), nullPart, s.constraint(c, model)]
+            .filter((part) => part !== '')
+            .join(' ');
+    };
+    return {
+        name: s.name,
+        limits: s.limits,
+        quoteIdent,
+        qualifiedTable,
+        read: s.read,
+        placeholder: (i) => s.placeholder(i),
+        columnType,
+        timestampParam: (d) => s.timestampParam(d),
+        buildInsert(model, rows) {
+            const cols = model.insertColumns;
+            const params = [];
+            const tuples = rows.map((row) => {
+                if (row.length !== cols.length) {
+                    throw new Error(`expected ${cols.length} values per row, got ${row.length}`);
+                }
+                const phs = row.map((value, idx) => {
+                    // A boolean headed for a real integer column (tinyint(1), smallint) is bound as 1/0.
+                    const target = cols[idx];
+                    params.push(typeof value === 'boolean' && target?.type.kind === 'boolean' && isIntegerColumn(target)
+                        ? value
+                            ? 1
+                            : 0
+                        : value);
+                    const ph = s.placeholder(params.length);
+                    return cols[idx]?.type.kind === 'json' && s.jsonCast !== undefined ? s.jsonCast(ph) : ph;
+                });
+                return `(${phs.join(', ')})`;
+            });
+            return {
+                sql: `INSERT INTO ${qualifiedTable(model.table)} (${cols.map((c) => quoteIdent(c.name)).join(', ')}) VALUES ${tuples.join(', ')}`,
+                params,
+            };
+        },
+        firstVisitLookup(model, kind, values) {
+            const col = kind === 'u' ? model.identity.userId : model.identity.ip;
+            if (col === undefined)
+                throw new Error('identity column is not mapped');
+            const phs = values.map((_, i) => s.placeholder(i + 1)).join(', ');
+            const userCol = model.identity.userId;
+            const extra = kind === 'i' && userCol !== undefined ? ` AND ${quoteIdent(userCol.name)} IS NULL` : '';
+            return {
+                sql: `SELECT DISTINCT ${quoteIdent(col.name)} AS v FROM ${qualifiedTable(model.table)} WHERE ${quoteIdent(col.name)} IN (${phs})${extra}`,
+                params: [...values],
+            };
+        },
+        introspectSql: (t) => s.introspectSql(t, quoteIdent),
+        mapColumnRow(row) {
+            const maxLength = toNum(row['max_length']);
+            return {
+                name: String(row['name']),
+                dataType: String(row['data_type']).toLowerCase(),
+                maxLength,
+                nullable: toBool(row['is_nullable']),
+                hasDefault: toBool(row['has_default']),
+                generated: toBool(row['is_generated']),
+                precision: toNum(row['dt_precision']),
+                tableType: typeof row['table_type'] === 'string' ? row['table_type'] : 'BASE TABLE',
+                ...(typeof row['schema_name'] === 'string' ? { schema: row['schema_name'] } : {}),
+            };
+        },
+        privilegeSql: (t) => s.privilegeSql(t, qualifiedTable(t)),
+        parsePrivileges: (results, t) => s.parsePrivileges(results, t),
+        createTableSql(model) {
+            const lines = model.columns.map((c) => ({
+                text: `${quoteIdent(c.name).padEnd(18)} ${columnDefinition(c, model)}`,
+                comment: describeComment(c),
+            }));
+            const constraints = s.tableConstraints(model, quoteIdent);
+            const all = [...lines, ...constraints.map((text) => ({ text, comment: '' }))];
+            const body = all
+                .map((l, i) => `  ${l.text}${i < all.length - 1 ? ',' : ''}${l.comment === '' ? '' : `  ${l.comment}`}`)
+                .join('\n');
+            return `CREATE TABLE ${qualifiedTable(model.table)} (\n${body}\n)${s.tableSuffix()};`;
+        },
+        createIndexSql(model) {
+            const table = qualifiedTable(model.table);
+            return indexSpecs(model).map((spec) => {
+                const name = quoteIdent(indexName(model.table.name, spec.suffix, s.limits.maxIdentifier));
+                const where = spec.whereNotNull !== undefined && s.supportsPartialIndex
+                    ? ` WHERE ${quoteIdent(spec.whereNotNull)} IS NOT NULL`
+                    : '';
+                return `CREATE INDEX ${name} ON ${table} (${spec.columns.map(quoteIdent).join(', ')})${where};`;
+            });
+        },
+        grantSql(opts) {
+            const writer = s.renderRole(opts.writerRole, quoteIdent);
+            const reader = s.renderRole(opts.readerRole, quoteIdent);
+            const target = s.grantTarget(opts.table, quoteIdent);
+            const out = [...s.grantPreamble(opts.table, writer, reader, quoteIdent)];
+            out.push('-- Application (writer): INSERT only. It cannot read anything back.');
+            out.push(`GRANT INSERT ON ${target} TO ${writer};`);
+            if (opts.writerSelectColumns !== undefined && opts.writerSelectColumns.length > 0) {
+                out.push('-- Needed only because firstVisit.enabled is on (write-time detection): column-level SELECT on identity columns.');
+                out.push(s.grantSelectColumns(target, opts.writerSelectColumns, writer, quoteIdent));
+            }
+            out.push('-- Dashboard (reader): SELECT only. This role can see PERSONAL DATA columns; protect it accordingly.');
+            out.push(`GRANT SELECT ON ${target} TO ${reader};`);
+            return out;
+        },
+        addColumnSql: (t, c) => `ALTER TABLE ${qualifiedTable(t)} ${s.addColumnKeyword} ${quoteIdent(c.name)} ${columnType(c)};`,
+        dropNotNullSql: (t, c) => s.dropNotNull(qualifiedTable(t), quoteIdent(c.name), columnType(c)),
+        alterTypeSql: (t, c) => s.alterType(qualifiedTable(t), quoteIdent(c.name), columnType(c)),
+        renderRole: (role) => s.renderRole(role, quoteIdent),
+    };
+}
+/** Shared role rendering: placeholders like <writer_role> pass through, real names must be valid identifiers. */
+export function renderRoleWith(role, wrap) {
+    if (PLACEHOLDER_ROLE.test(role))
+        return role;
+    if (!isIdentifier(role)) {
+        throw new DynaliticsConfigError([
+            `Role ${JSON.stringify(role)} is not supported. Use letters, digits and underscore (max 63), or leave the <placeholder>.`,
+        ]);
+    }
+    return wrap(role);
+}
+export { UNLIMITED };
+/** Guards for the few non-identifier values that are inlined into read SQL. */
+export function assertLimit(n) {
+    if (!Number.isInteger(n) || n < 1 || n > 100_000)
+        throw new Error('limit must be a positive integer');
+    return n;
+}
+export function assertJsonKey(key) {
+    if (!isCustomKey(key))
+        throw new Error('invalid custom field key');
+    return key;
+}
+//# sourceMappingURL=common.js.map

package/dist/dialect/index.d.ts

@@ -0,0 +1,5 @@
+import type { Dialect } from '../model/types.js';
+import type { SqlDialect } from './types.js';
+export declare function getDialect(name: Dialect): SqlDialect;
+export type { SqlDialect, CompiledQuery, ColumnInfo, Row, GrantOptions } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/dialect/index.js

@@ -0,0 +1,8 @@
+import { mssql } from './mssql.js';
+import { mysql } from './mysql.js';
+import { postgres } from './postgres.js';
+const DIALECTS = { postgres, mysql, mssql };
+export function getDialect(name) {
+    return DIALECTS[name];
+}
+//# sourceMappingURL=index.js.map

package/dist/dialect/mssql.d.ts

@@ -0,0 +1,3 @@
+import type { SqlDialect } from './types.js';
+export declare const mssql: SqlDialect;
+//# sourceMappingURL=mssql.d.ts.map

package/dist/dialect/mssql.js

@@ -0,0 +1,104 @@
+import { assertJsonKey, assertLimit, createDialect, qualify, renderRoleWith } from './common.js';
+const BIN_COLLATION = 'COLLATE Latin1_General_100_BIN2';
+function columnType(c) {
+    switch (c.type.kind) {
+        case 'id':
+            return 'BIGINT';
+        case 'timestamp':
+            return 'DATETIME2(3)';
+        case 'boolean':
+            return 'BIT';
+        case 'string':
+            return `NVARCHAR(${c.type.maxLength})`;
+        case 'integer':
+            return 'BIGINT';
+        case 'number':
+            return 'FLOAT(53)';
+        case 'json':
+            return 'NVARCHAR(MAX)';
+    }
+}
+export const mssql = createDialect({
+    name: 'mssql',
+    limits: { maxParams: 2100, maxRowsPerInsert: 1000, maxIdentifier: 128 },
+    open: '[',
+    close: ']',
+    explicitNull: true,
+    read: {
+        bucket: (col, interval) => {
+            const floor = {
+                hour: `DATEADD(hour, DATEDIFF(hour, 0, ${col}), 0)`,
+                day: `DATEADD(day, DATEDIFF(day, 0, ${col}), 0)`,
+                // 1900-01-01 is a Monday and DATEDIFF(day) ignores DATEFIRST, so weeks never depend on session settings.
+                week: `DATEADD(day, (DATEDIFF(day, '19000101', ${col}) / 7) * 7, '19000101')`,
+                month: `DATEADD(month, DATEDIFF(month, 0, ${col}), 0)`,
+            }[interval];
+            // Style 126 drops the fraction when it is zero (always, for a bucket start), so the fraction is written
+            // explicitly: every bucket key must equal the JavaScript toISOString() form exactly (found by the first CI run).
+            return `CONVERT(varchar(19), ${floor}, 126) + '.000Z'`;
+        },
+        // Same reason: style 126 would print 12:01:44Z for a visit at exactly .000 seconds.
+        tsText: (col) => `CONVERT(varchar(19), ${col}, 126) + '.' + RIGHT('00' + CAST(DATEPART(millisecond, ${col}) AS varchar(3)), 3) + 'Z'`,
+        isTrue: (col) => `${col} = 1`,
+        isFalse: (col) => `${col} = 0`,
+        jsonKey: (col, key) => `JSON_VALUE(${col}, '$.${assertJsonKey(key)}')`,
+        jsonNumber: (col, key) => `TRY_CAST(JSON_VALUE(${col}, '$.${assertJsonKey(key)}') AS float)`,
+        castText: (col, kind) => kind === 'string'
+            ? col
+            : kind === 'boolean'
+                ? `CASE WHEN ${col} = 1 THEN 'true' WHEN ${col} = 0 THEN 'false' END`
+                : `CAST(${col} AS NVARCHAR(4000))`,
+        count: 'COUNT_BIG(*)',
+        top: (n) => `TOP ${assertLimit(n)} `,
+        limit: () => '',
+    },
+    placeholder: (i) => `@p${i}`,
+    timestampParam: (d) => d.toISOString().replace('Z', ''),
+    columnType,
+    idDefinition: 'BIGINT IDENTITY(1,1) NOT NULL PRIMARY KEY',
+    collation: (c) => c.role === 'pageVisited' || c.role === 'ip' || c.role === 'userId' ? BIN_COLLATION : '',
+    constraint: (c, model) => c.role === 'custom'
+        ? `CONSTRAINT [CK_${model.table.name}_custom_json] CHECK ([${c.name}] IS NULL OR ISJSON([${c.name}]) = 1)`
+        : '',
+    tableSuffix: () => '',
+    tableConstraints: () => [],
+    addColumnKeyword: 'ADD',
+    dropNotNull: (table, name, type) => `ALTER TABLE ${table} ALTER COLUMN ${name} ${type} NULL;`,
+    alterType: (table, name, type) => `ALTER TABLE ${table} ALTER COLUMN ${name} ${type} NULL;`,
+    supportsPartialIndex: true,
+    introspectSql: (table, q) => {
+        const catalog = table.database === undefined ? '' : `${q(table.database)}.`;
+        return {
+            sql: `SELECT c.COLUMN_NAME AS name, c.DATA_TYPE AS data_type, c.CHARACTER_MAXIMUM_LENGTH AS max_length,
+       CASE WHEN c.IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS is_nullable,
+       CASE WHEN c.COLUMN_DEFAULT IS NOT NULL THEN 1 ELSE 0 END AS has_default,
+       CASE WHEN c.DATA_TYPE = 'timestamp'
+              OR COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.TABLE_CATALOG) + '.' + QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME)), c.COLUMN_NAME, 'IsIdentity') = 1
+              OR COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.TABLE_CATALOG) + '.' + QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME)), c.COLUMN_NAME, 'IsComputed') = 1
+            THEN 1 ELSE 0 END AS is_generated,
+       c.DATETIME_PRECISION AS dt_precision, t.TABLE_TYPE AS table_type, c.TABLE_SCHEMA AS schema_name
+FROM ${catalog}INFORMATION_SCHEMA.COLUMNS c
+JOIN ${catalog}INFORMATION_SCHEMA.TABLES t
+  ON t.TABLE_CATALOG = c.TABLE_CATALOG AND t.TABLE_SCHEMA = c.TABLE_SCHEMA AND t.TABLE_NAME = c.TABLE_NAME
+WHERE c.TABLE_SCHEMA = COALESCE(@p1, SCHEMA_NAME()) AND c.TABLE_NAME = @p2
+ORDER BY c.ORDINAL_POSITION`,
+            params: [table.schema ?? null, table.name],
+        };
+    },
+    privilegeSql: (_table, qualified) => [
+        {
+            sql: `SELECT permission_name AS privilege FROM fn_my_permissions(@p1, 'OBJECT')`,
+            params: [qualified],
+        },
+        {
+            sql: `SELECT 'SUPERUSER' AS privilege WHERE IS_SRVROLEMEMBER('sysadmin') = 1 OR IS_MEMBER('db_owner') = 1`,
+            params: [],
+        },
+    ],
+    parsePrivileges: (results) => new Set(results.flat().map((r) => String(r['privilege']).toUpperCase())),
+    grantTarget: (table, q) => `OBJECT::${qualify(table, q)}`,
+    grantSelectColumns: (target, columns, role, q) => `GRANT SELECT ON ${target} (${columns.map(q).join(', ')}) TO ${role};`,
+    renderRole: (role, q) => renderRoleWith(role, q),
+    grantPreamble: () => [],
+});
+//# sourceMappingURL=mssql.js.map

package/dist/dialect/mysql.d.ts

@@ -0,0 +1,3 @@
+import type { SqlDialect } from './types.js';
+export declare const mysql: SqlDialect;
+//# sourceMappingURL=mysql.d.ts.map

package/dist/dialect/mysql.js

@@ -0,0 +1,140 @@
+import { UNLIMITED, assertJsonKey, assertLimit, createDialect, qualify, renderRoleWith, } from './common.js';
+function columnType(c) {
+    switch (c.type.kind) {
+        case 'id':
+            return 'BIGINT UNSIGNED';
+        case 'timestamp':
+            return 'DATETIME(3)';
+        case 'boolean':
+            return 'TINYINT(1)';
+        case 'string':
+            return `VARCHAR(${c.type.maxLength})`;
+        case 'integer':
+            return 'BIGINT';
+        case 'number':
+            return 'DOUBLE';
+        case 'json':
+            return 'JSON';
+    }
+}
+const ALL_PRIVILEGES = [
+    'SELECT',
+    'INSERT',
+    'UPDATE',
+    'DELETE',
+    'DROP',
+    'ALTER',
+    'CREATE',
+    'REFERENCES',
+    'TRIGGER',
+];
+/** Best effort: parses `SHOW GRANTS` text for grants that apply to this table. Roles make it heuristic. */
+function parseGrants(results, table) {
+    const text = (v) => (typeof v === 'string' ? v : '');
+    const grants = (results[0] ?? []).map((r) => text(Object.values(r)[0]));
+    const currentDb = text(results[1]?.[0]?.['db']);
+    const db = table.schema ?? currentDb;
+    const unescape = (s) => s.replace(/\\([_%])/g, '$1');
+    const found = new Set();
+    for (const line of grants) {
+        const m = /^GRANT (.+?) ON (.+?) TO /.exec(line);
+        if (m === null)
+            continue;
+        const scope = (m[2] ?? '').replace(/`/g, '');
+        const [scopeDb = '', scopeTable = ''] = scope.split('.');
+        const applies = scope === '*.*' ||
+            (unescape(scopeDb) === db && (scopeTable === '*' || scopeTable === table.name));
+        if (!applies)
+            continue;
+        const privs = (m[1] ?? '')
+            .replace(/\([^)]*\)/g, '')
+            .split(',')
+            .map((p) => p.trim().toUpperCase());
+        for (const p of privs) {
+            if (p === 'ALL PRIVILEGES' || p === 'ALL')
+                ALL_PRIVILEGES.forEach((x) => found.add(x));
+            else if (p !== 'USAGE' && p !== '')
+                found.add(p);
+        }
+        if (/WITH GRANT OPTION\s*$/.test(line))
+            found.add('GRANT OPTION');
+    }
+    return found;
+}
+export const mysql = createDialect({
+    name: 'mysql',
+    limits: { maxParams: 65_535, maxRowsPerInsert: UNLIMITED, maxIdentifier: 64 },
+    open: '`',
+    close: '`',
+    explicitNull: false,
+    read: {
+        bucket: (col, interval) => {
+            switch (interval) {
+                case 'hour':
+                    return `DATE_FORMAT(${col}, '%Y-%m-%dT%H:00:00.000Z')`;
+                case 'day':
+                    return `DATE_FORMAT(${col}, '%Y-%m-%dT00:00:00.000Z')`;
+                case 'week':
+                    return `DATE_FORMAT(DATE_SUB(DATE(${col}), INTERVAL WEEKDAY(${col}) DAY), '%Y-%m-%dT00:00:00.000Z')`;
+                case 'month':
+                    return `DATE_FORMAT(${col}, '%Y-%m-01T00:00:00.000Z')`;
+            }
+        },
+        tsText: (col) => `CONCAT(DATE_FORMAT(${col}, '%Y-%m-%dT%H:%i:%s.'), LPAD(MICROSECOND(${col}) DIV 1000, 3, '0'), 'Z')`,
+        isTrue: (col) => `${col} = 1`,
+        isFalse: (col) => `${col} = 0`,
+        jsonKey: (col, key) => `JSON_UNQUOTE(JSON_EXTRACT(${col}, '$.${assertJsonKey(key)}'))`,
+        jsonNumber: (col, key) => {
+            const v = `JSON_EXTRACT(${col}, '$.${assertJsonKey(key)}')`;
+            return `CASE WHEN JSON_TYPE(${v}) IN ('INTEGER', 'UNSIGNED INTEGER', 'DOUBLE', 'DECIMAL') THEN CAST(${v} AS DOUBLE) END`;
+        },
+        castText: (col, kind) => kind === 'string'
+            ? col
+            : kind === 'boolean'
+                ? `CASE WHEN ${col} = 1 THEN 'true' WHEN ${col} = 0 THEN 'false' END`
+                : `CAST(${col} AS CHAR)`,
+        count: 'COUNT(*)',
+        top: () => '',
+        limit: (n) => ` LIMIT ${assertLimit(n)}`,
+    },
+    placeholder: () => '?',
+    timestampParam: (d) => d.toISOString().replace('T', ' ').replace('Z', ''),
+    columnType,
+    idDefinition: 'BIGINT UNSIGNED NOT NULL AUTO_INCREMENT',
+    collation: () => '',
+    constraint: () => '',
+    tableSuffix: () => ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin',
+    tableConstraints: (model, q) => {
+        const id = model.columns.find((c) => c.role === 'id');
+        return id === undefined ? [] : [`PRIMARY KEY (${q(id.name)})`];
+    },
+    addColumnKeyword: 'ADD COLUMN',
+    dropNotNull: (table, name, type) => `ALTER TABLE ${table} MODIFY COLUMN ${name} ${type} NULL;`,
+    alterType: (table, name, type) => `ALTER TABLE ${table} MODIFY COLUMN ${name} ${type};`,
+    supportsPartialIndex: false,
+    introspectSql: (table) => ({
+        sql: `SELECT c.COLUMN_NAME AS name, c.DATA_TYPE AS data_type, c.CHARACTER_MAXIMUM_LENGTH AS max_length,
+       (c.IS_NULLABLE = 'YES') AS is_nullable, (c.COLUMN_DEFAULT IS NOT NULL) AS has_default,
+       (c.EXTRA LIKE '%auto_increment%' OR c.EXTRA LIKE '%GENERATED%') AS is_generated,
+       c.DATETIME_PRECISION AS dt_precision, t.TABLE_TYPE AS table_type, c.TABLE_SCHEMA AS schema_name
+FROM information_schema.COLUMNS c
+JOIN information_schema.TABLES t ON t.TABLE_SCHEMA = c.TABLE_SCHEMA AND t.TABLE_NAME = c.TABLE_NAME
+WHERE c.TABLE_SCHEMA = COALESCE(?, DATABASE()) AND c.TABLE_NAME = ?
+ORDER BY c.ORDINAL_POSITION`,
+        params: [table.schema ?? null, table.name],
+    }),
+    privilegeSql: () => [
+        { sql: 'SHOW GRANTS FOR CURRENT_USER()', params: [] },
+        { sql: 'SELECT DATABASE() AS db', params: [] },
+    ],
+    parsePrivileges: (results, table) => parseGrants(results, table),
+    grantTarget: (table, q) => (table.schema === undefined ? q(table.name) : qualify(table, q)),
+    grantSelectColumns: (target, columns, role, q) => `GRANT SELECT (${columns.map(q).join(', ')}) ON ${target} TO ${role};`,
+    renderRole: (role, q) => renderRoleWith(role, (name) => `${q(name)}@\`%\``),
+    grantPreamble: (table) => table.schema === undefined
+        ? [
+            '-- No schema given: these grants apply to the current database. Use schema.name to be explicit.',
+        ]
+        : [],
+});
+//# sourceMappingURL=mysql.js.map

package/dist/dialect/postgres.d.ts

@@ -0,0 +1,5 @@
+import { PLACEHOLDER_ROLE } from './common.js';
+import type { SqlDialect } from './types.js';
+export declare const postgres: SqlDialect;
+export { PLACEHOLDER_ROLE };
+//# sourceMappingURL=postgres.d.ts.map

package/dist/dialect/postgres.js

@@ -0,0 +1,90 @@
+import { PLACEHOLDER_ROLE, UNLIMITED, assertJsonKey, assertLimit, createDialect, qualify, renderRoleWith, } from './common.js';
+function columnType(c) {
+    switch (c.type.kind) {
+        case 'id':
+            return 'bigint';
+        case 'timestamp':
+            return 'timestamptz';
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return `varchar(${c.type.maxLength})`;
+        case 'integer':
+            return 'bigint';
+        case 'number':
+            return 'double precision';
+        case 'json':
+            return 'jsonb';
+    }
+}
+export const postgres = createDialect({
+    name: 'postgres',
+    limits: { maxParams: 65_535, maxRowsPerInsert: UNLIMITED, maxIdentifier: 63 },
+    open: '"',
+    close: '"',
+    explicitNull: false,
+    read: {
+        bucket: (col, interval) => `to_char(date_trunc('${interval}', ${col} AT TIME ZONE 'UTC'), 'YYYY-MM-DD"T"HH24:MI:SS".000Z"')`,
+        tsText: (col) => `to_char(${col} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"')`,
+        isTrue: (col) => `${col} IS TRUE`,
+        isFalse: (col) => `${col} IS FALSE`,
+        jsonKey: (col, key) => `(${col} ->> '${assertJsonKey(key)}')`,
+        // SIMILAR TO, not ~: F-39 allows no '~' outside literals. PostgreSQL has no TRY_CAST.
+        jsonNumber: (col, key) => {
+            const v = `(${col} ->> '${assertJsonKey(key)}')`;
+            return `CASE WHEN ${v} SIMILAR TO '-?[0-9]+([.][0-9]+)?([eE][-+]?[0-9]+)?' THEN CAST(${v} AS double precision) END`;
+        },
+        castText: (col, kind) => kind === 'string'
+            ? col
+            : kind === 'boolean'
+                ? `CASE WHEN ${col} IS TRUE THEN 'true' WHEN ${col} IS FALSE THEN 'false' END`
+                : `CAST(${col} AS text)`,
+        count: 'COUNT(*)',
+        top: () => '',
+        limit: (n) => ` LIMIT ${assertLimit(n)}`,
+    },
+    placeholder: (i) => `$${i}`,
+    jsonCast: (ph) => `${ph}::jsonb`,
+    timestampParam: (d) => d.toISOString(),
+    columnType,
+    idDefinition: 'bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY',
+    collation: () => '',
+    constraint: () => '',
+    tableSuffix: () => '',
+    tableConstraints: () => [],
+    addColumnKeyword: 'ADD COLUMN',
+    dropNotNull: (table, name) => `ALTER TABLE ${table} ALTER COLUMN ${name} DROP NOT NULL;`,
+    alterType: (table, name, type) => `ALTER TABLE ${table} ALTER COLUMN ${name} TYPE ${type} USING ${name}::${type};`,
+    supportsPartialIndex: true,
+    introspectSql: (table) => ({
+        sql: `SELECT c.column_name AS name, c.udt_name AS data_type, c.character_maximum_length AS max_length,
+       (c.is_nullable = 'YES') AS is_nullable, (c.column_default IS NOT NULL) AS has_default,
+       (c.is_identity = 'YES' OR c.is_generated = 'ALWAYS') AS is_generated,
+       c.datetime_precision AS dt_precision, t.table_type AS table_type, c.table_schema AS schema_name
+FROM information_schema.columns c
+JOIN information_schema.tables t ON t.table_schema = c.table_schema AND t.table_name = c.table_name
+WHERE c.table_schema = COALESCE($1::text, current_schema()) AND c.table_name = $2::text
+ORDER BY c.ordinal_position`,
+        params: [table.schema ?? null, table.name],
+    }),
+    privilegeSql: (_table, qualified) => [
+        {
+            sql: `SELECT p AS privilege FROM unnest(ARRAY['SELECT','INSERT','UPDATE','DELETE','TRUNCATE','REFERENCES','TRIGGER']) AS p
+WHERE has_table_privilege(current_user, $1::text, p)`,
+            params: [qualified],
+        },
+        {
+            sql: `SELECT 'SUPERUSER' AS privilege FROM pg_roles WHERE rolname = current_user AND rolsuper`,
+            params: [],
+        },
+    ],
+    parsePrivileges: (results) => new Set(results.flat().map((r) => String(r['privilege']).toUpperCase())),
+    grantTarget: (table, q) => qualify(table, q),
+    grantSelectColumns: (target, columns, role, q) => `GRANT SELECT (${columns.map(q).join(', ')}) ON ${target} TO ${role};`,
+    renderRole: (role, q) => renderRoleWith(role, q),
+    grantPreamble: (table, writer, reader, q) => table.schema === undefined
+        ? []
+        : [`GRANT USAGE ON SCHEMA ${q(table.schema)} TO ${writer}, ${reader};`],
+});
+export { PLACEHOLDER_ROLE };
+//# sourceMappingURL=postgres.js.map