ts-prorm-orm 1.1.0

package/dist/dialects/cratedb/index.js

@@ -0,0 +1,441 @@
+"use strict";
+/**
+ * CrateDB dialect implementation for the TypeScript ORM
+ *
+ * CrateDB is a distributed SQL database that speaks the PostgreSQL wire protocol
+ * (default port 5432) and is largely PG-compatible on the client side, so this
+ * dialect extends `PostgresDialect` and reuses the `pg` driver for connectivity
+ * and most query building. It overrides the schema-generation surface (CREATE
+ * TABLE + type mapping) to emit CrateDB-native SQL. Notable differences from the
+ * Postgres dialect:
+ *
+ * - Default port stays 5432 (PG-wire-compatible), so the constructor forwards
+ *   `{ port: 5432, ...config }` to the Postgres base.
+ * - CREATE TABLE supports CrateDB's distribution/partitioning clauses, emitted in
+ *   CrateDB's required order: `PARTITIONED BY (col)`, then
+ *   `CLUSTERED [BY (col)] INTO n SHARDS`, then a `WITH ( ... )` settings block.
+ *   Example:
+ *     CREATE TABLE "t" (...) PARTITIONED BY ("day")
+ *       CLUSTERED BY ("id") INTO 6 SHARDS
+ *       WITH (number_of_replicas = '1', "refresh_interval" = 1000)
+ * - Type mapping is CrateDB-specific: TEXT, INTEGER, BIGINT, DOUBLE PRECISION,
+ *   BOOLEAN, TIMESTAMP, OBJECT and GEO_POINT (rather than Postgres VARCHAR/SERIAL/
+ *   JSONB/etc). Composite/semi-structured types use CrateDB syntax:
+ *     * OBJECT columns emit `OBJECT(DYNAMIC) AS (col type, ...)` (or bare `OBJECT`
+ *       when no sub-columns are declared). The column policy defaults to DYNAMIC.
+ *     * ARRAY columns emit `ARRAY(type)` (CrateDB's array syntax) rather than
+ *       Postgres's `type[]`.
+ * - PRIMARY KEY is preserved. NOTE: in CrateDB a PRIMARY KEY must include every
+ *   routing/clustered/partitioned column (CrateDB requires routing columns to be
+ *   part of the primary key). The dialect does not attempt to validate or rewrite
+ *   the PRIMARY KEY to enforce this — it is the caller's responsibility.
+ * - FOREIGN KEYs are OMITTED. CrateDB has no foreign-key support, so both
+ *   column-level `references` and any `FOREIGN KEY` table constraints are dropped
+ *   from generated DDL rather than emitted.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrateDBDialect = void 0;
+exports.createCrateDBDialect = createCrateDBDialect;
+const postgres_1 = require("../postgres");
+/**
+ * CrateDB dialect class. Extends the PostgreSQL dialect (PG-wire compatible) and
+ * overrides CREATE TABLE generation and type mapping for CrateDB.
+ */
+class CrateDBDialect extends postgres_1.PostgresDialect {
+    constructor(config) {
+        // CrateDB is PG-wire-compatible and listens on 5432 by default.
+        super({ port: 5432, ...config });
+        this.name = 'cratedb';
+    }
+    /**
+     * Map an ORM data type to its CrateDB SQL type. Overrides the Postgres mapping
+     * to emit CrateDB-native types (TEXT, INTEGER, BIGINT, DOUBLE PRECISION,
+     * BOOLEAN, TIMESTAMP, OBJECT, GEO_POINT) and CrateDB's `OBJECT(...)`/`ARRAY(...)`
+     * syntax for semi-structured/collection types.
+     */
+    getDataTypeSql(dataType) {
+        if (typeof dataType === 'string') {
+            const s = dataType.trim();
+            // The shared model-sync layer emits cross-dialect pseudo/PG types as
+            // strings; normalize the common ones to their CrateDB equivalents.
+            if (/^DATETIME(\(\d+\))?$/i.test(s))
+                return 'TIMESTAMP';
+            if (/^(VARCHAR|CHARACTER\s+VARYING|CHARACTER|CHAR|STRING|NVARCHAR|NCHAR|TEXT|CLOB)(\(.*\))?$/i.test(s)) {
+                return 'TEXT';
+            }
+            if (/^JSONB?$/i.test(s) || /^HSTORE$/i.test(s))
+                return 'OBJECT';
+            if (/^UUID$/i.test(s))
+                return 'TEXT';
+            if (/^(SERIAL|BIGSERIAL|SMALLSERIAL)$/i.test(s))
+                return 'BIGINT';
+            if (/^(REAL|FLOAT|NUMERIC|DECIMAL|DOUBLE(\s+PRECISION)?)(\(.*\))?$/i.test(s)) {
+                return 'DOUBLE PRECISION';
+            }
+            if (/^(TIMESTAMP|TIMESTAMPTZ|DATE|TIME)(\(\d+\))?$/i.test(s))
+                return 'TIMESTAMP';
+            return s;
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return 'TEXT';
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+            case 'CHAR':
+            case 'TEXT':
+            case 'ENUM':
+            case 'UUID':
+            case 'INET':
+            case 'CIDR':
+            case 'MACADDR':
+                return 'TEXT';
+            case 'INTEGER':
+                return 'INTEGER';
+            case 'BIGINT':
+                return 'BIGINT';
+            case 'FLOAT':
+            case 'DOUBLE':
+            case 'DECIMAL':
+                return 'DOUBLE PRECISION';
+            case 'BOOLEAN':
+                return 'BOOLEAN';
+            case 'DATE':
+            case 'DATEONLY':
+            case 'TIME':
+                return 'TIMESTAMP';
+            case 'JSON':
+            case 'JSONB':
+            case 'HSTORE':
+            case 'OBJECT':
+                return this.buildObjectTypeSql(dt);
+            case 'ARRAY': {
+                // CrateDB uses ARRAY(type), not Postgres's type[].
+                const arrayType = dt.type || dt.subtype;
+                const base = arrayType ? this.getDataTypeSql(arrayType) : 'TEXT';
+                return `ARRAY(${base})`;
+            }
+            case 'GEOMETRY':
+            case 'GEOGRAPHY':
+            case 'GEO_POINT':
+                return 'GEO_POINT';
+            case 'GEO_SHAPE':
+                return 'GEO_SHAPE';
+            case 'VIRTUAL':
+                return '';
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * Build the CrateDB `OBJECT` type SQL. Emits `OBJECT(POLICY) AS (col type, ...)`
+     * when sub-columns are declared, otherwise a bare `OBJECT`. The column policy
+     * defaults to DYNAMIC (CrateDB's default).
+     */
+    buildObjectTypeSql(dt) {
+        const policy = String(dt.columnPolicy || dt.policy || 'DYNAMIC').toUpperCase();
+        const fields = dt.fields || dt.columns || dt.properties;
+        if (fields && typeof fields === 'object') {
+            const inner = Object.entries(fields)
+                .map(([name, def]) => {
+                // A field value is either a DataType directly (has `.key`, e.g. an
+                // ARRAY type which itself carries a `.type` subtype) or a
+                // ColumnDefinition wrapper (`{ type: DataType }`). Only unwrap `.type`
+                // when there's no `.key`, so an ARRAY DataType isn't misread as a wrapper.
+                const d = def;
+                const type = d && d.key === undefined && d.type !== undefined
+                    ? def.type
+                    : def;
+                return `${this.escapeId(name)} ${this.getDataTypeSql(type)}`;
+            })
+                .join(', ');
+            return `OBJECT(${policy}) AS (${inner})`;
+        }
+        return 'OBJECT';
+    }
+    /**
+     * Format a value for a `WITH ( key = value )` table setting: strings are
+     * single-quoted (with embedded quotes escaped), numbers/booleans are bare.
+     */
+    formatSettingValue(value) {
+        if (typeof value === 'string') {
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        return String(value);
+    }
+    /**
+     * Format a CrateDB column DEFAULT value.
+     */
+    formatDefaultValue(value) {
+        if (value === null)
+            return 'NULL';
+        if (typeof value === 'string') {
+            if (value.toUpperCase().includes('CURRENT_') || value.toUpperCase() === 'NULL') {
+                return value;
+            }
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (typeof value === 'object' &&
+            value !== null &&
+            typeof value.toDefaultValue === 'function') {
+            return value.toDefaultValue();
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    /**
+     * Build a single CrateDB column definition. FOREIGN KEY references are omitted
+     * (CrateDB has no FK support).
+     */
+    getCrateColumnDefinitionSql(columnName, definition) {
+        const typeSql = this.getDataTypeSql(definition.type);
+        // VIRTUAL columns map to an empty type and produce no column.
+        if (!typeSql)
+            return '';
+        let sql = `${this.escapeId(columnName)} ${typeSql}`;
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.formatDefaultValue(definition.defaultValue)}`;
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+        }
+        // definition.references is intentionally ignored: CrateDB has no FOREIGN KEYs.
+        return sql;
+    }
+    /**
+     * Build a CrateDB table constraint. FOREIGN KEY constraints are omitted
+     * (CrateDB has no FK support); PRIMARY KEY / UNIQUE / CHECK are passed through.
+     */
+    buildCrateConstraintSql(constraint) {
+        if (constraint.type === 'FOREIGN KEY') {
+            // CrateDB does not support foreign keys — drop the constraint entirely.
+            return null;
+        }
+        const name = constraint.name ? `${this.escapeId(constraint.name)} ` : '';
+        const fields = constraint.fields?.map((f) => this.escapeId(f)).join(', ') || '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `${name}PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${name}UNIQUE (${fields})`;
+            case 'CHECK':
+                if (!constraint.check)
+                    return null;
+                return `${name}CHECK (${constraint.check})`;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Build the CrateDB `CREATE TABLE` statement (synchronous, no execution).
+     *
+     * Emits clauses in CrateDB's required order after the column list:
+     *   1. `PARTITIONED BY (col, ...)`
+     *   2. `CLUSTERED [BY (col)] INTO n SHARDS`
+     *   3. `WITH ( key = value, ... )`
+     *
+     * FOREIGN KEY references/constraints are omitted (unsupported by CrateDB).
+     */
+    buildCreateTableSQL(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            const columnSql = this.getCrateColumnDefinitionSql(columnName, definition);
+            if (columnSql) {
+                columnDefs.push(columnSql);
+            }
+        }
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildCrateConstraintSql(constraint);
+                if (constraintSql) {
+                    columnDefs.push(constraintSql);
+                }
+            }
+        }
+        // Fulltext INDEX columns (CrateDB's only user-defined index kind) are
+        // declared inline in the column list, e.g.
+        //   INDEX "ft_body" USING FULLTEXT ("title", "body") WITH (analyzer = 'english')
+        if (options?.fulltextIndexes) {
+            for (const ft of options.fulltextIndexes) {
+                const cols = ft.fields.map((f) => this.escapeId(f)).join(', ');
+                let ftSql = `INDEX ${this.escapeId(ft.name)} USING FULLTEXT (${cols})`;
+                if (ft.analyzer) {
+                    ftSql += ` WITH (analyzer = ${this.formatSettingValue(ft.analyzer)})`;
+                }
+                columnDefs.push(ftSql);
+            }
+        }
+        let sql = 'CREATE TABLE';
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // 1. PARTITIONED BY
+        if (options?.partitionedBy) {
+            const cols = Array.isArray(options.partitionedBy)
+                ? options.partitionedBy
+                : [options.partitionedBy];
+            sql += ` PARTITIONED BY (${cols.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        // 2. CLUSTERED [BY (col)] INTO n SHARDS
+        const clusteredBy = options?.clusteredBy;
+        const shards = options?.clusteredInto ?? options?.shards;
+        if (clusteredBy || shards !== undefined) {
+            let clustered = 'CLUSTERED';
+            if (clusteredBy) {
+                clustered += ` BY (${this.escapeId(clusteredBy)})`;
+            }
+            if (shards !== undefined) {
+                clustered += ` INTO ${shards} SHARDS`;
+            }
+            sql += ` ${clustered}`;
+        }
+        // 3. WITH ( key = value, ... )
+        const withOpts = options?.with;
+        if (withOpts && Object.keys(withOpts).length > 0) {
+            const pairs = Object.entries(withOpts).map(([key, value]) => `${key} = ${this.formatSettingValue(value)}`);
+            sql += ` WITH (${pairs.join(', ')})`;
+        }
+        return sql;
+    }
+    /**
+     * Create a new table in CrateDB.
+     *
+     * Overrides the Postgres implementation to emit CrateDB's CREATE TABLE syntax
+     * (CLUSTERED / PARTITIONED BY / WITH, CrateDB type mapping, no foreign keys).
+     */
+    async createTable(tableName, columns, options) {
+        const sql = this.buildCreateTableSQL(tableName, columns, options);
+        await this.query(sql);
+        // CrateDB has no standalone CREATE INDEX statement: every column is
+        // automatically indexed (a plain index), and the only user-defined indexes
+        // are fulltext indexes, which are declared inline at CREATE TABLE via the
+        // `fulltextIndexes` option (handled in buildCreateTableSQL). Generic
+        // `options.indexes` therefore cannot be honored — warn rather than emit
+        // invalid `CREATE INDEX` SQL.
+        if (options?.indexes && options.indexes.length > 0) {
+            console.warn(`CrateDB: ${options.indexes.length} secondary index(es) on "${tableName}" ignored — ` +
+                'CrateDB auto-indexes all columns; use the fulltextIndexes option for fulltext search.');
+        }
+    }
+    async addIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error(CrateDBDialect.NO_CREATE_INDEX);
+    }
+    async createIndex(_tableName, _indexDef) {
+        throw new Error(CrateDBDialect.NO_CREATE_INDEX);
+    }
+    async createFulltextIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error('CrateDB fulltext indexes cannot be added after table creation — declare them at ' +
+            'CREATE TABLE via the fulltextIndexes option (INDEX ... USING FULLTEXT (...)).');
+    }
+    async createSpatialIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error('CrateDB has no spatial index statement: GEO_SHAPE columns take an inline INDEX ' +
+            'definition at CREATE TABLE time, not a separate CREATE INDEX.');
+    }
+    async removeIndex(_tableName, _indexName) {
+        throw new Error(CrateDBDialect.NO_CREATE_INDEX);
+    }
+    async dropIndex(_tableName, _indexName, _options) {
+        throw new Error(CrateDBDialect.NO_CREATE_INDEX);
+    }
+    // ---------------------------------------------------------------------------
+    // CrateDB has no FOREIGN KEY support. The inherited Postgres methods would
+    // emit FK DDL that CrateDB rejects, so reject FK operations explicitly.
+    // ---------------------------------------------------------------------------
+    async addForeignKey(_tableName, _columnName, _referencedTableName, _referencedColumnName, _options) {
+        throw new Error('CrateDB does not support foreign keys.');
+    }
+    async addConstraint(tableName, options) {
+        if (options.type === 'FOREIGN KEY') {
+            throw new Error('CrateDB does not support foreign keys.');
+        }
+        return super.addConstraint(tableName, options);
+    }
+    async createConstraint(tableName, constraintDef) {
+        if (constraintDef.type === 'FOREIGN KEY') {
+            throw new Error('CrateDB does not support foreign keys.');
+        }
+        return super.createConstraint(tableName, constraintDef);
+    }
+    // ---------------------------------------------------------------------------
+    // ALTER TABLE differences.
+    // ---------------------------------------------------------------------------
+    /**
+     * Add a column via `ALTER TABLE t ADD COLUMN ...`. Overrides the Postgres
+     * implementation so the column uses CrateDB's type mapping and drops any FK
+     * reference (CrateDB supports ADD COLUMN but not SERIAL/REFERENCES).
+     */
+    async addColumn(tableName, columnName, definition) {
+        const columnSql = this.getCrateColumnDefinitionSql(columnName, definition);
+        if (!columnSql)
+            return;
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${columnSql}`);
+    }
+    /**
+     * CrateDB cannot rename columns via ALTER TABLE (no `RENAME COLUMN`).
+     */
+    async renameColumn(_tableName, _oldColumnName, _newColumnName) {
+        throw new Error('CrateDB does not support renaming columns.');
+    }
+    /**
+     * CrateDB cannot rename tables via ALTER TABLE (no `RENAME TO`).
+     */
+    async renameTable(_oldName, _newName) {
+        throw new Error('CrateDB does not support renaming tables.');
+    }
+    // ---------------------------------------------------------------------------
+    // INSERT / UPSERT. CrateDB supports `ON CONFLICT (pk) DO UPDATE SET ...`
+    // (identical to Postgres — buildUpsertQuery / buildInsertQuery upsert output
+    // is reused unchanged) and additionally `ON CONFLICT [(pk)] DO NOTHING`.
+    // ---------------------------------------------------------------------------
+    buildInsertQuery(tableName, values, options) {
+        if (options?.onConflictDoNothing) {
+            // Build a plain INSERT (no upsert/RETURNING), then append DO NOTHING and
+            // RETURNING in the correct order. CrateDB allows DO NOTHING without a
+            // conflict target, so conflictFields is optional here.
+            const base = super.buildInsertQuery(tableName, values, {
+                ...options,
+                upsert: false,
+                returning: undefined,
+            });
+            let sql = base.sql + ' ON CONFLICT';
+            if (options.conflictFields && options.conflictFields.length > 0) {
+                sql += ` (${options.conflictFields.map((c) => this.escapeId(c)).join(', ')})`;
+            }
+            sql += ' DO NOTHING';
+            if (options.returning === true) {
+                sql += ' RETURNING *';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+            }
+            return { sql, values: base.values };
+        }
+        return super.buildInsertQuery(tableName, values, options);
+    }
+}
+exports.CrateDBDialect = CrateDBDialect;
+// ---------------------------------------------------------------------------
+// CrateDB has no CREATE INDEX / DROP INDEX. Every column is auto-indexed, and
+// fulltext indexes must be declared at CREATE TABLE (see fulltextIndexes /
+// buildCreateTableSQL). The inherited Postgres index methods would emit SQL
+// CrateDB rejects, so they're overridden to throw with actionable guidance.
+// ---------------------------------------------------------------------------
+CrateDBDialect.NO_CREATE_INDEX = 'CrateDB has no CREATE INDEX statement: all columns are automatically indexed. ' +
+    'For fulltext search, declare a fulltext index at CREATE TABLE via the ' +
+    'fulltextIndexes option (INDEX ... USING FULLTEXT (...)).';
+/**
+ * Create a new CrateDB dialect instance
+ */
+function createCrateDBDialect(options) {
+    return new CrateDBDialect(options || {});
+}
+exports.default = CrateDBDialect;