ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/redshift/index.js

@@ -50,13 +50,25 @@
  *   (`CREATE OR REPLACE PROCEDURE ... LANGUAGE plpgsql`), so those are
  *   implemented much like Postgres.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedshiftTransaction = exports.RedshiftDialect = void 0;
 exports.createRedshiftDialect = createRedshiftDialect;
-const pg_1 = __importDefault(require("pg"));
+// Lazily-loaded `pg` driver. Required only when a connection is opened, so
+// importing this ORM never loads the pg driver.
+let pgModule = null;
+function loadPg() {
+    if (!pgModule) {
+        try {
+            pgModule = require('pg');
+        }
+        catch (err) {
+            throw new Error("The 'pg' package is required to use the Redshift dialect but could not be loaded. " +
+                'Install it with `npm install pg`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return pgModule;
+}
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
 const index_1 = require("../../errors/index");
@@ -117,7 +129,7 @@ class RedshiftDialect {
     // ---------------------------------------------------------------------------
     async connect() {
         try {
-            const { Pool: PgPool } = pg_1.default;
+            const { Pool: PgPool } = loadPg();
             this.pool = new PgPool({
                 host: this.config.host,
                 port: this.config.port,

package/dist/dialects/singlestore/index.d.ts

@@ -0,0 +1,233 @@
+/**
+ * SingleStore (formerly MemSQL) dialect implementation for the TypeScript ORM.
+ *
+ * SingleStore is MySQL-wire-compatible, so this dialect extends
+ * {@link MySQLDialect} and reuses the exact same `mysql2` driver, connection
+ * pooling, query execution, escaping, WHERE/ORDER/INSERT/UPDATE/DELETE/SELECT
+ * builders, JSON helpers, etc. Only the grammar that genuinely differs from
+ * stock MySQL is overridden here.
+ *
+ * Notable differences from the MySQL dialect:
+ *
+ * - `name` is `'singlestore'` (the driver/`library` is still `'mysql2'`).
+ * - Default SQL port is 3306 (same wire protocol as MySQL).
+ * - Table storage kind: SingleStore tables are columnstore by default. A
+ *   `ROWSTORE` table can be requested with `{ rowstore: true }`, which emits
+ *   `CREATE ROWSTORE TABLE ...`.
+ * - `SHARD KEY (cols)`: SingleStore is a distributed database and shards data
+ *   across leaf nodes by a shard key. `{ shardKey: ['id'] }` emits
+ *   `SHARD KEY (id)`. An empty array (`{ shardKey: [] }`) emits a keyless
+ *   `SHARD KEY ()` (random sharding), which is also how a plain distributed
+ *   table with no explicit shard key is declared.
+ * - `SORT KEY (cols)`: columnstore tables store rows ordered by a sort key.
+ *   `{ sortKey: ['created_at'] }` emits `SORT KEY (created_at)`.
+ * - `KEY (...) USING CLUSTERED COLUMNSTORE`: the explicit clustered-columnstore
+ *   key form, requested with `{ columnstoreKey: { fields: [...] } }`.
+ * - Reference tables: `{ reference: true }` emits `CREATE REFERENCE TABLE ...`.
+ *   Reference tables are fully replicated to every node (rather than sharded),
+ *   and are typically used for small dimension tables joined against large
+ *   sharded fact tables.
+ *
+ * CAVEAT — foreign keys: SingleStore does NOT support foreign key constraints
+ * (a real server rejects `FOREIGN KEY ... REFERENCES ...`). This dialect
+ * therefore refuses to emit FK SQL rather than generating statements that
+ * would fail:
+ *   - CREATE TABLE: table-level FOREIGN KEY constraints and column-level
+ *     `references` are omitted (the table is still created, minus the FK).
+ *   - {@link addForeignKey} and {@link createConstraint} with a FOREIGN KEY
+ *     type throw a clear error.
+ *   - {@link addColumn} / {@link changeColumn} strip any column `references`.
+ * Enforce referential integrity in application code instead.
+ *
+ * CAVEAT — upserts: SingleStore's `ON DUPLICATE KEY UPDATE` uses the classic
+ * `VALUES(col)` reference, not the MySQL 8.0.19 row-alias form
+ * (`... AS new_row ... = new_row.col`) that the MySQL base emits. This dialect
+ * overrides {@link buildInsertQuery} / {@link buildUpsertQuery} to emit the
+ * `VALUES(col)` form.
+ *
+ * CAVEAT — unique constraints on columnstore tables must include the shard key;
+ * this is a SingleStore data-distribution rule that the ORM does not attempt to
+ * police.
+ */
+import { MySQLDialect, MySQLDialectOptions } from '../mysql/index';
+import { ColumnDefinition, TableOptions, InsertOptions } from '../dialect';
+import { DataType, TriggerOptions, DropTriggerOptions } from '../../types';
+/**
+ * SingleStore connection options. Identical to {@link MySQLDialectOptions}
+ * since the wire protocol and `mysql2` driver are shared.
+ */
+export interface SingleStoreDialectOptions extends MySQLDialectOptions {
+}
+/**
+ * SingleStore-specific `CREATE TABLE` options. Layered on top of the shared
+ * {@link TableOptions} via an intersection type so callers targeting
+ * SingleStore can pass these alongside the common options.
+ */
+export interface SingleStoreTableOptions {
+    /**
+     * Create a ROWSTORE (in-memory rowstore) table instead of the default
+     * on-disk columnstore. Emits `CREATE ROWSTORE TABLE ...`.
+     */
+    rowstore?: boolean;
+    /**
+     * Create a REFERENCE table (fully replicated to every node instead of
+     * sharded). Emits `CREATE REFERENCE TABLE ...`.
+     */
+    reference?: boolean;
+    /**
+     * Shard key columns. `['user_id']` emits `SHARD KEY (user_id)`. An empty
+     * array emits a keyless `SHARD KEY ()` for random sharding. Reference
+     * tables are replicated rather than sharded, so a shard key is normally
+     * omitted for them.
+     */
+    shardKey?: string[];
+    /** Sort key columns for a columnstore table. Emits `SORT KEY (cols)`. */
+    sortKey?: string[];
+    /**
+     * Explicit clustered columnstore key. Emits
+     * `KEY (cols) USING CLUSTERED COLUMNSTORE`.
+     */
+    columnstoreKey?: {
+        fields: string[];
+    };
+    /**
+     * Universal-storage (seekable columnstore) secondary hash indexes. Each
+     * entry emits `KEY (cols) USING HASH`, which gives a columnstore table fast
+     * single-row seeks/unique enforcement without leaving universal storage.
+     * Pass `{ fields, unique: true }` to emit `UNIQUE KEY (cols) USING HASH`.
+     * `['col']` shorthand is treated as a non-unique hash key on that column.
+     */
+    hashKeys?: Array<string | {
+        fields: string[];
+        unique?: boolean;
+    }>;
+}
+/**
+ * SingleStore dialect. Reuses the MySQL (`mysql2`) driver and all of
+ * MySQLDialect's behavior, overriding only the CREATE TABLE grammar that
+ * differs (storage kind, SHARD KEY, SORT KEY, clustered columnstore key,
+ * reference tables).
+ */
+export declare class SingleStoreDialect extends MySQLDialect {
+    readonly name = "singlestore";
+    constructor(config: SingleStoreDialectOptions);
+    /**
+     * Build the `CREATE TABLE` SQL string for SingleStore, synchronously.
+     *
+     * Exposed as a standalone (non-async, no I/O) method so the emitted grammar
+     * can be inspected/tested without a live connection. `createTable()` below
+     * delegates to it.
+     */
+    buildCreateTableSQL(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & SingleStoreTableOptions): string;
+    /**
+     * Create a new table using SingleStore grammar. Overrides MySQLDialect's
+     * createTable so shard/sort/columnstore keys and storage kind are honored.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & SingleStoreTableOptions): Promise<void>;
+    /**
+     * Build a single column definition. Reimplemented here (rather than reusing
+     * MySQLDialect's private helper) using only public dialect methods, so the
+     * synchronous SQL builder stays self-contained.
+     */
+    private buildColumnSQL;
+    /**
+     * Build a table-level constraint clause.
+     *
+     * SingleStore does NOT support FOREIGN KEY constraints — a real server
+     * rejects `FOREIGN KEY (...) REFERENCES ...` in CREATE TABLE with a syntax
+     * error. So FOREIGN KEY constraints are silently OMITTED here (the table is
+     * still created without the referential-integrity clause) rather than
+     * emitting SQL that would fail. PRIMARY KEY / UNIQUE / CHECK are supported
+     * and emitted normally.
+     */
+    private buildTableConstraintSQL;
+    /**
+     * Map an ORM DataType to SingleStore column SQL.
+     *
+     * SingleStore is largely MySQL-type-compatible, so the MySQL mapping is
+     * reused for everything EXCEPT geospatial types: SingleStore has a native
+     * `GEOGRAPHY` type (and `GEOGRAPHYPOINT`), whereas stock MySQL has no
+     * `GEOGRAPHY` type and the base dialect degrades it to `GEOMETRY`. Emit the
+     * native SingleStore type instead so geography columns round-trip correctly.
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build an INSERT query.
+     *
+     * Overrides the MySQL base ONLY for the upsert (`ON DUPLICATE KEY UPDATE`)
+     * branch: the base uses the row-alias form (`... AS new_vals ON DUPLICATE
+     * KEY UPDATE col = new_vals.col`) introduced in MySQL 8.0.19, which
+     * SingleStore does not support. SingleStore uses the classic
+     * `VALUES(col)` reference instead. The plain (non-upsert) INSERT is
+     * identical to MySQL.
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT query (`INSERT ... ON DUPLICATE KEY UPDATE`).
+     *
+     * Uses the classic `VALUES(col)` form rather than the MySQL 8.0.19 row-alias
+     * form the base emits, since SingleStore does not support the row alias.
+     * Like MySQL, SingleStore has no `RETURNING` clause, so a `returning`
+     * request fails fast.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: {
+        conflictFields?: string[];
+        updateOnDuplicate?: string[];
+        returning?: boolean | string[];
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Add a column. SingleStore does not support foreign keys, so any
+     * column-level `references` is stripped before delegating to the MySQL base
+     * (whose column builder would otherwise emit a `REFERENCES ...` clause that
+     * SingleStore rejects).
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Change a column. As with {@link addColumn}, any column-level `references`
+     * is stripped since SingleStore does not support foreign keys.
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * SingleStore does not support foreign key constraints. Reject explicit
+     * foreign-key operations with a clear error rather than emitting SQL a real
+     * server would refuse.
+     */
+    addForeignKey(_tableName: string, _columnName: string, _referencedTableName: string, _referencedColumnName: string, _options?: any): Promise<void>;
+    /**
+     * Create a constraint. PRIMARY KEY / UNIQUE / CHECK delegate to the MySQL
+     * base; FOREIGN KEY is rejected because SingleStore does not support it.
+     */
+    createConstraint(tableName: string, constraintDef: {
+        name: string;
+        type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+        fields?: string[];
+        references?: {
+            table: string;
+            field: string;
+            onDelete?: string;
+            onUpdate?: string;
+        };
+        check?: string;
+    }): Promise<void>;
+    createTrigger(_options: TriggerOptions): Promise<void>;
+    dropTrigger(_triggerName: string, _tableName: string, _options?: DropTriggerOptions): Promise<void>;
+    hasTrigger(_triggerName: string, _tableName: string): Promise<boolean>;
+    listTriggers(_tableName?: string): Promise<string[]>;
+    createSavepointSQL(_name?: string): string;
+    releaseSavepointSQL(_name: string): string;
+    rollbackToSavepointSQL(_name: string): string;
+    /** Return a shallow copy of the column definition without its `references`. */
+    private stripReferences;
+    /**
+     * Format a column DEFAULT value. Passes SQL functions (CURRENT_TIMESTAMP,
+     * etc.) and NULL through unquoted; everything else is escaped via the
+     * shared `escape()`.
+     */
+    private formatDefaultValue;
+}

package/dist/dialects/singlestore/index.js

@@ -105,6 +105,18 @@ class SingleStoreDialect extends index_1.MySQLDialect {
             const cols = opts.columnstoreKey.fields.map((c) => this.escapeId(c)).join(', ');
             parts.push(`KEY (${cols}) USING CLUSTERED COLUMNSTORE`);
         }
+        // KEY (...) USING HASH — universal-storage seekable hash index(es). Gives a
+        // columnstore table fast single-row lookups / unique enforcement without
+        // converting it to a rowstore table.
+        if (opts.hashKeys && opts.hashKeys.length > 0) {
+            for (const hk of opts.hashKeys) {
+                const spec = typeof hk === 'string' ? { fields: [hk], unique: false } : hk;
+                if (!spec.fields || spec.fields.length === 0)
+                    continue;
+                const cols = spec.fields.map((c) => this.escapeId(c)).join(', ');
+                parts.push(`${spec.unique ? 'UNIQUE ' : ''}KEY (${cols}) USING HASH`);
+            }
+        }
         // CREATE [ROWSTORE] [REFERENCE] TABLE [IF NOT EXISTS] name (...)
         let sql = 'CREATE';
         if (opts.rowstore) {
@@ -330,6 +342,47 @@ class SingleStoreDialect extends index_1.MySQLDialect {
         }
         return super.createConstraint(tableName, constraintDef);
     }
+    // ---------------------------------------------------------------------------
+    // Triggers — NOT supported by SingleStore.
+    //
+    // SingleStore has no `CREATE TRIGGER` support at all (a real server rejects
+    // it). The MySQL base would happily emit trigger DDL, so override the trigger
+    // surface to fail fast with a clear capability error rather than sending SQL
+    // the server refuses. Enforce the equivalent logic in application code, a
+    // stored procedure, or a computed column instead.
+    // ---------------------------------------------------------------------------
+    async createTrigger(_options) {
+        throw new Error('SingleStore does not support triggers (CREATE TRIGGER). Implement the logic in application code, a stored procedure, or a computed column instead.');
+    }
+    async dropTrigger(_triggerName, _tableName, _options) {
+        throw new Error('SingleStore does not support triggers, so there is nothing to drop.');
+    }
+    async hasTrigger(_triggerName, _tableName) {
+        // SingleStore has no triggers, so one can never exist.
+        return false;
+    }
+    async listTriggers(_tableName) {
+        // SingleStore has no triggers.
+        return [];
+    }
+    // ---------------------------------------------------------------------------
+    // Savepoints — NOT supported by SingleStore.
+    //
+    // SingleStore transactions do not support `SAVEPOINT` / `ROLLBACK TO
+    // SAVEPOINT` / `RELEASE SAVEPOINT`. The MySQL base emits these verbatim, so
+    // override the SQL builders to throw a clear capability error instead of
+    // returning SQL that would fail at execution time. Use a full
+    // commit/rollback of the surrounding transaction instead.
+    // ---------------------------------------------------------------------------
+    createSavepointSQL(_name) {
+        throw new Error('SingleStore does not support savepoints. Use a full transaction commit/rollback instead of SAVEPOINT.');
+    }
+    releaseSavepointSQL(_name) {
+        throw new Error('SingleStore does not support savepoints (RELEASE SAVEPOINT is unavailable).');
+    }
+    rollbackToSavepointSQL(_name) {
+        throw new Error('SingleStore does not support savepoints (ROLLBACK TO SAVEPOINT is unavailable). Roll back the whole transaction instead.');
+    }
     /** Return a shallow copy of the column definition without its `references`. */
     stripReferences(definition) {
         if (!definition.references) {