ts-prorm-orm 1.1.0 → 1.2.1

package/dist/dialects/snowflake/index.js

@@ -25,12 +25,24 @@
  *  - Auth supports both password auth and key-pair auth (privateKey /
  *    privateKeyPath), matching the snowflake-sdk driver's ConnectionOptions.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnowflakeDialect = void 0;
-const snowflake_sdk_1 = __importDefault(require("snowflake-sdk"));
+// Lazily-loaded `snowflake-sdk` driver. Required only when a connection is
+// opened, so importing this ORM never loads the Snowflake driver.
+let snowflakeModule = null;
+function loadSnowflake() {
+    if (!snowflakeModule) {
+        try {
+            snowflakeModule = require('snowflake-sdk');
+        }
+        catch (err) {
+            throw new Error("The 'snowflake-sdk' package is required to use the Snowflake dialect but could not be loaded. " +
+                'Install it with `npm install snowflake-sdk`. Original error: ' +
+                (err instanceof Error ? err.message : String(err)));
+        }
+    }
+    return snowflakeModule;
+}
 const types_1 = require("../../types");
 const query_stream_helper_1 = require("../query-stream-helper");
 const prorm_1 = require("../../prorm");
@@ -96,7 +108,7 @@ class SnowflakeDialect {
             clientSessionKeepAlive: this.config.clientSessionKeepAlive,
         };
         try {
-            const conn = snowflake_sdk_1.default.createConnection(options);
+            const conn = loadSnowflake().createConnection(options);
             await new Promise((resolve, reject) => {
                 conn.connect((err) => {
                     if (err) {
@@ -2051,6 +2063,143 @@ class SnowflakeDialect {
         const result = await this.query('SHOW TASKS');
         return result.rows?.map((row) => row.name || row.NAME) || [];
     }
+    // ---------------------------------------------------------------------------
+    // Materialized views & Dynamic Tables
+    //
+    // Snowflake has two declarative-refresh table objects: classic MATERIALIZED
+    // VIEWs (single-table, auto-maintained) and the newer DYNAMIC TABLEs
+    // (multi-table joins/aggregations refreshed to a TARGET_LAG). Both are
+    // exposed here so callers never hand-write the DDL.
+    // ---------------------------------------------------------------------------
+    /**
+     * `CREATE [OR REPLACE] [SECURE] MATERIALIZED VIEW <name> AS <query>`.
+     * Snowflake materialized views are single-table, automatically maintained by
+     * the service. Pass `secure: true` for a SECURE materialized view (hides the
+     * definition/optimizer internals for data sharing).
+     */
+    async createMaterializedView(viewName, query, options) {
+        let sql = options?.replace ? 'CREATE OR REPLACE' : 'CREATE';
+        if (options?.secure)
+            sql += ' SECURE';
+        sql += ` MATERIALIZED VIEW ${this.quoteTable(viewName, options?.schema)}`;
+        if (options?.clusterBy && options.clusterBy.length > 0) {
+            sql += ` CLUSTER BY (${options.clusterBy.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        if (options?.comment)
+            sql += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        sql += ` AS ${query}`;
+        await this.query(sql);
+    }
+    async dropMaterializedView(viewName, options) {
+        let sql = 'DROP MATERIALIZED VIEW';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.quoteTable(viewName, options?.schema)}`;
+        await this.query(sql);
+    }
+    /**
+     * `CREATE [OR REPLACE] DYNAMIC TABLE <name> TARGET_LAG = '...' WAREHOUSE = ...
+     * AS <query>`. Dynamic tables are Snowflake's declarative, automatically
+     * refreshed alternative to materialized views for multi-table
+     * transforms/rollups; `targetLag` (e.g. `'1 minute'` or `'DOWNSTREAM'`) sets
+     * the freshness target and `warehouse` runs the refresh.
+     */
+    async createDynamicTable(name, query, options) {
+        let sql = options.replace ? 'CREATE OR REPLACE DYNAMIC TABLE' : 'CREATE DYNAMIC TABLE';
+        if (!options.replace && options.ifNotExists)
+            sql += ' IF NOT EXISTS';
+        sql += ` ${this.quoteTable(name, options.schema)}`;
+        sql += ` TARGET_LAG = '${this.escapeString(options.targetLag)}'`;
+        sql += ` WAREHOUSE = ${this.escapeId(options.warehouse)}`;
+        if (options.clusterBy && options.clusterBy.length > 0) {
+            sql += ` CLUSTER BY (${options.clusterBy.map((c) => this.escapeId(c)).join(', ')})`;
+        }
+        if (options.comment)
+            sql += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        sql += ` AS ${query}`;
+        await this.query(sql);
+    }
+    async dropDynamicTable(name, options) {
+        let sql = 'DROP DYNAMIC TABLE';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.quoteTable(name, options?.schema)}`;
+        await this.query(sql);
+    }
+    /** Manually refresh a dynamic table: `ALTER DYNAMIC TABLE <name> REFRESH`. */
+    async refreshDynamicTable(name, schema) {
+        await this.query(`ALTER DYNAMIC TABLE ${this.quoteTable(name, schema)} REFRESH`);
+    }
+    // ---------------------------------------------------------------------------
+    // UNDROP (Time Travel restore) & GET_DDL introspection
+    // ---------------------------------------------------------------------------
+    /**
+     * `UNDROP TABLE <name>` — restore a table dropped within the Time Travel
+     * retention window. Snowflake's counterpart to an accidental-DROP undo; also
+     * available for schemas/databases via {@link undropSchema}/{@link undropDatabase}.
+     */
+    async undropTable(tableName, schema) {
+        await this.query(`UNDROP TABLE ${this.quoteTable(tableName, schema)}`);
+    }
+    async undropSchema(schema) {
+        await this.query(`UNDROP SCHEMA ${this.escapeId(schema)}`);
+    }
+    async undropDatabase(name) {
+        await this.query(`UNDROP DATABASE ${this.escapeId(name)}`);
+    }
+    /**
+     * Fetch the full `CREATE` DDL for an object via `SELECT GET_DDL(<type>, <name>)`.
+     * Higher fidelity than parsing `DESCRIBE TABLE` rows — returns the exact,
+     * reproducible statement Snowflake would use to recreate the object.
+     *
+     * @param objectType - e.g. `'TABLE'`, `'VIEW'`, `'FUNCTION'`, `'PROCEDURE'`, `'SCHEMA'`.
+     */
+    async getDdl(objectType, name, schema) {
+        const qualified = schema ? `${schema}.${name}` : name;
+        const result = await this.query(`SELECT GET_DDL('${this.escapeString(objectType.toUpperCase())}', '${this.escapeString(qualified)}') AS DDL`);
+        const row = result.rows?.[0];
+        return (row?.DDL ?? row?.ddl ?? '');
+    }
+    // ---------------------------------------------------------------------------
+    // User-Defined Functions (UDFs) — distinct from stored procedures.
+    // ---------------------------------------------------------------------------
+    /**
+     * `CREATE [OR REPLACE] [SECURE] FUNCTION <name>(args) RETURNS <type>
+     * [LANGUAGE ...] AS $$ <body> $$`. UDFs return a value (scalar or table) and
+     * are callable inline in SQL, unlike stored procedures. `language` defaults to
+     * SQL; JavaScript/Python/Java UDFs pass the matching `language` + `body`.
+     */
+    async createFunction(name, options) {
+        let sql = options.replace ? 'CREATE OR REPLACE' : 'CREATE';
+        if (options.secure)
+            sql += ' SECURE';
+        sql += ' FUNCTION';
+        const args = (options.args || [])
+            .map((a) => `${this.escapeId(a.name)} ${a.type}`)
+            .join(', ');
+        sql += ` ${this.quoteTable(name, options.schema)}(${args})`;
+        sql += ` RETURNS ${options.returns}`;
+        if (options.language && options.language !== 'SQL') {
+            sql += ` LANGUAGE ${options.language}`;
+        }
+        if (options.immutable)
+            sql += ' IMMUTABLE';
+        if (options.runtimeVersion)
+            sql += ` RUNTIME_VERSION = '${this.escapeString(options.runtimeVersion)}'`;
+        if (options.handler)
+            sql += ` HANDLER = '${this.escapeString(options.handler)}'`;
+        if (options.comment)
+            sql += ` COMMENT = '${this.escapeString(options.comment)}'`;
+        sql += ` AS $$${options.body}$$`;
+        await this.query(sql);
+    }
+    async dropFunction(name, argTypes = [], options) {
+        let sql = 'DROP FUNCTION';
+        if (options?.ifExists)
+            sql += ' IF EXISTS';
+        sql += ` ${this.quoteTable(name, options?.schema)}(${argTypes.join(', ')})`;
+        await this.query(sql);
+    }
     /**
      * Build an expression to shred a JSON document/array into relational rows.
      * Snowflake has no `JSON_TABLE`; its real equivalent is the `FLATTEN` table function