@runnerty/executor-snowflake 1.0.0

package/.prettierignore

@@ -0,0 +1,10 @@
+node_modules
+.all-contributorsrc
+.eslintignore
+.gitignore
+.prettierignore
+LICENSE
+*.sql
+*.png
+*.txt
+TODO

package/.prettierrc.json

@@ -0,0 +1,10 @@
+{
+  "printWidth": 120,
+  "singleQuote": true,
+  "useTabs": false,
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "trailingComma": "none",
+  "arrowParens": "avoid"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Runnerty Tech S.L.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,277 @@
+<p align="center">
+  <a href="http://runnerty.io">
+    <img height="257" src="https://runnerty.io/assets/header/logo-stroked.png">
+  </a>
+  <p align="center">Smart Processes Management</p>
+</p>
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url]
+<a href="#badge">
+<img alt="code style: prettier" src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg">
+</a>
+
+# Snowflake executor for [Runnerty]:
+
+### Installation:
+
+Through NPM
+
+```bash
+npm i @runnerty/executor-snowflake
+```
+
+You can also add modules to your project with [runnerty-cli]
+
+```bash
+npx runnerty-cli add @runnerty/executor-snowflake
+```
+
+This command installs the module in your project, adds example configuration in your `config.json` and creates an example plan of use.
+
+If you have installed [runnerty-cli] globally you can include the module with this command:
+
+```bash
+rty add @runnerty/executor-snowflake
+```
+
+### Configuration:
+
+Add in [config.json]:
+
+#### OAuth Authentication (Recommended):
+
+This executor uses OAuth token authentication by default. You need to configure your OAuth token provider and set the following environment variables:
+
+```bash
+export SNOWFLAKE_ACCOUNT="myaccount.us-east-1"
+export SNOWFLAKE_USERNAME="myuser@company.com"
+export SNOWFLAKE_PASSWORD="mypassword"
+```
+
+```json
+{
+  "id": "snowflake_default",
+  "type": "@runnerty-executor-snowflake",
+  "account": "@ENV(SNOWFLAKE_ACCOUNT)",
+  "username": "@ENV(SNOWFLAKE_USERNAME)",
+  "database": "@ENV(SNOWFLAKE_DATABASE)",
+  "schema": "@ENV(SNOWFLAKE_SCHEMA)",
+  "warehouse": "@ENV(SNOWFLAKE_WAREHOUSE)",
+  "role": "@ENV(SNOWFLAKE_ROLE)"
+}
+```
+
+#### Direct Configuration:
+
+```json
+{
+  "id": "snowflake_default",
+  "type": "@runnerty-executor-snowflake",
+  "account": "myaccount.us-east-1",
+  "username": "myuser@company.com",
+  "database": "MYDATABASE",
+  "schema": "PUBLIC",
+  "warehouse": "COMPUTE_WH",
+  "role": "MYROLE"
+}
+```
+
+#### Configuration params:
+
+| Parameter   | Description                                                     |
+| :---------- | :-------------------------------------------------------------- |
+| account     | Snowflake account identifier (e.g., "myaccount.us-east-1")      |
+| username    | The Snowflake user to authenticate as.                          |
+| database    | Name of the database to use for this connection. (Optional)     |
+| schema      | Name of the schema to use for this connection. (Optional)       |
+| warehouse   | Name of the warehouse to use for this connection. (Optional)    |
+| role        | Name of the role to use for this connection. (Optional)         |
+| timeout     | Connection timeout in milliseconds. (Default: 60000)            |
+| application | Application name for connection tracking. (Default: "runnerty") |
+
+### Plan samples:
+
+Add in [plan.json]:
+
+#### Basic query:
+
+```json
+{
+  "id": "snowflake_default",
+  "command_file": "./sql/my_query.sql"
+}
+```
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT CURRENT_TIMESTAMP() as now, CURRENT_USER() as user"
+}
+```
+
+#### Query with parameters:
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT * FROM users WHERE created_date >= :start_date AND status = :status",
+  "args": {
+    "start_date": "2023-01-01",
+    "status": "active"
+  }
+}
+```
+
+#### Export to files:
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT * FROM sales_data WHERE year = 2023",
+  "xlsxFileExport": "./reports/sales_2023.xlsx",
+  "xlsxSheetName": "Sales Report",
+  "xlsxAuthorName": "Data Team"
+}
+```
+
+### Generation of files:
+
+The results can be exported to csv, xlsx and json format files. These files are generated using streams for optimal performance with large datasets.
+You only have to indicate the corresponding property in the parameters:
+
+#### XLSX
+
+XLSX Format with streaming support for large datasets.
+
+| Parameter      | Description                   |
+| :------------- | :---------------------------- |
+| xlsxFileExport | Path of xlsx file export.     |
+| xlsxAuthorName | Author file name. (Optional)  |
+| xlsxSheetName  | Name of the sheet. (Optional) |
+
+Sample:
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT * FROM users",
+  "xlsxFileExport": "./exports/users.xlsx",
+  "xlsxAuthorName": "Runnerty",
+  "xlsxSheetName": "Users Data"
+}
+```
+
+#### CSV
+
+CSV Format with streaming support and customizable options.
+
+| Parameter               | Description                                                           |
+| :---------------------- | :-------------------------------------------------------------------- |
+| csvFileExport           | Path of csv file export.                                              |
+| csvOptions/headers      | Type: boolean. Whether to include headers in the CSV. (Default: true) |
+| csvOptions/delimiter    | Alternate delimiter. (Default: ',')                                   |
+| csvOptions/quote        | Alternate quote. (Default: '"')                                       |
+| csvOptions/rowDelimiter | Specify an alternate row delimiter (i.e \r\n). (Default: '\n')        |
+| csvOptions/escape       | Alternate escaping value. (Default: '"')                              |
+
+Sample:
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT * FROM users",
+  "csvFileExport": "@GV(WORK_DIR)/users.csv",
+  "csvOptions": {
+    "delimiter": ";",
+    "quote": "\"",
+    "headers": true
+  }
+}
+```
+
+#### JSON
+
+JSON Format with streaming support.
+
+| Parameter      | Description               |
+| :------------- | :------------------------ |
+| jsonFileExport | Path of json file export. |
+
+Sample:
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT * FROM users",
+  "jsonFileExport": "@GV(WORK_DIR)/users.json"
+}
+```
+
+### Output (Process values):
+
+#### Standard
+
+- `PROCESS_EXEC_MSG_OUTPUT`: Snowflake output message.
+- `PROCESS_EXEC_ERR_OUTPUT`: Error output message.
+- `PROCESS_EXEC_COMMAND_EXECUTED`: Executed SQL command.
+
+#### Query output
+
+- `PROCESS_EXEC_DATA_OUTPUT`: Snowflake query output data (array of objects).
+- `PROCESS_EXEC_DB_COUNTROWS`: Snowflake query count rows.
+- `PROCESS_EXEC_DB_FIRSTROW`: Snowflake query first row data (object).
+- `PROCESS_EXEC_DB_FIRSTROW_[FIELD_NAME]`: Snowflake first row field data.
+
+Example of first row field access:
+
+```json
+{
+  "id": "snowflake_default",
+  "command": "SELECT user_id, email, created_date FROM users LIMIT 1"
+}
+```
+
+Available variables after execution:
+
+- `PROCESS_EXEC_DB_FIRSTROW_USER_ID`: First row user_id value
+- `PROCESS_EXEC_DB_FIRSTROW_EMAIL`: First row email value
+- `PROCESS_EXEC_DB_FIRSTROW_CREATED_DATE`: First row created_date value
+
+### Authentication Setup:
+
+This executor requires OAuth authentication setup. Make sure you have:
+
+1. **Environment variables configured:**
+
+   ```bash
+   export SNOWFLAKE_ACCOUNT="your-account"
+   export SNOWFLAKE_USERNAME="your-username"
+   export SNOWFLAKE_PASSWORD="your-password"
+   ```
+
+2. **OAuth token provider configured** (internal API endpoint)
+
+3. **Required dependencies installed:**
+   ```bash
+   npm install snowflake-sdk axios exceljs fast-csv jsonstream
+   ```
+
+### Features:
+
+- ✅ **OAuth Authentication** - Secure token-based authentication
+- ✅ **Streaming Support** - Efficient processing of large datasets
+- ✅ **Multiple Export Formats** - XLSX, CSV, JSON
+- ✅ **Parameterized Queries** - Support for `:parameter` placeholders
+- ✅ **Environment Variables** - Secure configuration management
+- ✅ **Error Handling** - Comprehensive error reporting
+- ✅ **Connection Pooling** - Optimized connection management
+
+[runnerty]: http://www.runnerty.io
+[downloads-image]: https://img.shields.io/npm/dm/@runnerty/executor-snowflake.svg
+[npm-url]: https://www.npmjs.com/package/@runnerty/executor-snowflake
+[npm-image]: https://img.shields.io/npm/v/@runnerty/executor-snowflake.svg
+[david-badge]: https://david-dm.org/runnerty/executor-snowflake.svg
+[david-badge-url]: https://david-dm.org/runnerty/executor-snowflake
+[config.json]: http://docs.runnerty.io/config/
+[runnerty-cli]: https://www.npmjs.com/package/runnerty-cli
+[plan.json]: http://docs.runnerty.io/plan/

package/get-token.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const axios = require('axios');
+
+/**
+ * Obtiene un token OAuth desde la API de AWS
+ * @returns {Promise<string>} Token OAuth
+ */
+async function getToken(params) {
+  const url = params.url;
+
+  const headers = {
+    'Content-Type': 'application/json'
+  };
+
+  const body = JSON.stringify({
+    username: params.user,
+    password: params.password
+  });
+
+  try {
+    const response = await axios({
+      method: 'post',
+      url: url,
+      headers: headers,
+      data: body
+    });
+
+    const token = response.data?.token;
+
+    if (!token) {
+      throw new Error('Token not found in response');
+    }
+
+    return token;
+  } catch (error) {
+    console.error('❌ Error getting token:', error.message);
+    if (error.response) {
+      console.error('Response status:', error.response.status);
+      console.error('Response data:', error.response.data);
+    }
+    throw error;
+  }
+}
+// Exportar las funciones
+module.exports = {
+  getToken
+};

package/index.js

@@ -0,0 +1,455 @@
+'use strict';
+
+const snowflake = require('snowflake-sdk');
+const fs = require('fs');
+const fsp = require('fs').promises;
+const path = require('path');
+const JSONStream = require('jsonstream');
+const Excel = require('exceljs');
+const csv = require('fast-csv');
+const { getToken } = require('./get-token');
+
+const Executor = require('@runnerty/module-core').Executor;
+
+class snowflakeExecutor extends Executor {
+  constructor(process) {
+    super(process);
+    this.ended = false;
+    this.endOptions = {
+      end: 'end'
+    };
+  }
+
+  async exec(params) {
+    try {
+      // Cargar comando SQL
+      if (!params.command) {
+        if (params.command_file) {
+          try {
+            await fsp.access(params.command_file, fs.constants.F_OK | fs.constants.W_OK);
+            params.command = await fsp.readFile(params.command_file, 'utf8');
+          } catch (err) {
+            throw new Error(`Load SQLFile: ${err}`);
+          }
+        } else {
+          this.endOptions.end = 'error';
+          this.endOptions.messageLog = 'execute-snowflake dont have command or command_file';
+          this.endOptions.err_output = 'execute-snowflake dont have command or command_file';
+          this._end(this.endOptions);
+          return;
+        }
+      }
+
+      const query = await this.prepareQuery(params);
+      this.endOptions.command_executed = query;
+
+      // Crear conexión y ejecutar consulta
+      const connection = await this.createConnection(params);
+      await this.executeQuery(connection, query);
+    } catch (error) {
+      this.error(error);
+    }
+  }
+
+  async createConnection(params) {
+    try {
+      const token = await getToken(params);
+
+      const connectionOptions = this.getConnectionOptions(params, token);
+
+      return new Promise((resolve, reject) => {
+        const connection = snowflake.createConnection(connectionOptions);
+
+        // Usar connect normal con token OAuth
+        connection.connect((err, conn) => {
+          if (err) {
+            reject(new Error(`Snowflake connection error: ${err.message}`));
+          } else {
+            resolve(conn);
+          }
+        });
+      });
+    } catch (error) {
+      throw new Error(`Failed to get token or connect: ${error.message}`);
+    }
+  }
+
+  getConnectionOptions(params, token) {
+    return {
+      account: params.account,
+      username: params.user,
+      authenticator: 'oauth', // Especificar que usamos OAuth
+      token: token, // Token OAuth obtenido de la API
+      database: params.database,
+      schema: params.schema,
+      warehouse: params.warehouse,
+      role: params.role,
+      timeout: params.timeout || 60000,
+      application: params.application || 'runnerty'
+    };
+  }
+
+  async executeQuery(connection, query) {
+    return new Promise((resolve, reject) => {
+      connection.execute({
+        sqlText: query,
+        streamResult: true,
+        complete: (err, stmt, rows) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          // Procesar resultados con streaming si está disponible
+          if (stmt.streamRows) {
+            const results = [];
+            let firstRow = {};
+            let rowCounter = 0;
+            const stream = stmt.streamRows();
+
+            stream.on('data', row => {
+              if (rowCounter === 0) firstRow = row;
+              results.push(row);
+              rowCounter++;
+            });
+
+            stream.on('end', () => {
+              this.prepareEndOptions(firstRow, rowCounter, results);
+              this._end(this.endOptions);
+              connection.destroy();
+              resolve();
+            });
+
+            stream.on('error', error => {
+              reject(error);
+            });
+          } else {
+            // Fallback sin streaming
+            this.prepareEndOptions(rows[0], rows ? rows.length : 0, rows);
+            this._end(this.endOptions);
+            connection.destroy();
+            resolve();
+          }
+        }
+      });
+    });
+  }
+
+  error(err, connection) {
+    console.error('❌ Snowflake Error:', err.message || err);
+    this.endOptions.end = 'error';
+    this.endOptions.messageLog = `execute-snowflake: ${err.message || err}`;
+    this.endOptions.err_output = `execute-snowflake: ${err.message || err}`;
+    if (connection) connection.destroy();
+    this._end(this.endOptions);
+  }
+
+  _end(endOptions) {
+    if (!this.ended) {
+      this.ended = true;
+      super.end(endOptions);
+    }
+  }
+
+  async prepareQuery(values) {
+    let query = values.command;
+
+    // Reemplazar argumentos en la consulta
+    if (values.args) {
+      for (const key in values.args) {
+        const regex = new RegExp(`:${key}`, 'g');
+        query = query.replace(regex, values.args[key]);
+      }
+    }
+
+    return query;
+  }
+
+  prepareEndOptions(firstRow, rowCounter, results) {
+    this.endOptions.data_output = results || [];
+    this.endOptions.extra_output = {
+      db_countrows: rowCounter || 0,
+      db_firstrow: firstRow || {}
+    };
+
+    // Variables globales para Runnerty
+    if (firstRow) {
+      Object.keys(firstRow).forEach(key => {
+        this.endOptions[`db_firstrow_${key.toLowerCase()}`] = firstRow[key];
+      });
+    }
+  }
+
+  async queryToJSON(connection, query, params) {
+    try {
+      // Verificar que el directorio del archivo de exportación existe
+      await fsp.access(path.dirname(params.jsonFileExport));
+
+      const fileStreamWriter = fs.createWriteStream(params.jsonFileExport);
+
+      fileStreamWriter.on('error', error => {
+        this.error(error, connection);
+      });
+
+      return new Promise((resolve, reject) => {
+        connection.execute({
+          sqlText: query,
+          streamResult: true,
+          complete: (err, stmt, rows) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+
+            // Usar streaming si está disponible
+            if (stmt.streamRows) {
+              let firstRow = {};
+              let rowCounter = 0;
+              let isFirstRow = true;
+              const stream = stmt.streamRows();
+
+              stream.on('data', row => {
+                if (isFirstRow) {
+                  firstRow = row;
+                  isFirstRow = false;
+                }
+                rowCounter++;
+              });
+
+              stream.on('end', () => {
+                this.prepareEndOptions(firstRow, rowCounter);
+                this._end(this.endOptions);
+                connection.destroy();
+                resolve();
+              });
+
+              stream.on('error', error => {
+                this.error(error, connection);
+                reject(error);
+              });
+
+              // Pipe los datos a JSON y luego al archivo
+              stream.pipe(JSONStream.stringify()).pipe(fileStreamWriter);
+            } else {
+              // Fallback sin streaming - escribir directamente los rows
+              fileStreamWriter.write(JSON.stringify(rows, null, 2));
+              fileStreamWriter.end();
+
+              fileStreamWriter.on('finish', () => {
+                this.prepareEndOptions(rows[0], rows ? rows.length : 0);
+                this._end(this.endOptions);
+                connection.destroy();
+                resolve();
+              });
+            }
+          }
+        });
+      });
+    } catch (err) {
+      this.error(err, connection);
+    }
+  }
+
+  async queryToXLSX(connection, query, params) {
+    try {
+      // Verificar que el directorio del archivo de exportación existe
+      await fsp.access(path.dirname(params.xlsxFileExport));
+
+      const fileStreamWriter = fs.createWriteStream(params.xlsxFileExport);
+
+      const options = {
+        stream: fileStreamWriter,
+        useStyles: true,
+        useSharedStrings: true
+      };
+      const workbook = new Excel.stream.xlsx.WorkbookWriter(options);
+
+      const author = 'Runnerty';
+      const sheetName = 'Sheet';
+      const sheet = workbook.addWorksheet(params.xlsxSheetName ? params.xlsxSheetName : sheetName);
+      workbook.creator = params.xlsxAuthorName ? params.xlsxAuthorName : author;
+      workbook.lastPrinted = new Date();
+
+      fileStreamWriter.on('error', error => {
+        this.error(error, connection);
+      });
+
+      return new Promise((resolve, reject) => {
+        connection.execute({
+          sqlText: query,
+          streamResult: true,
+          complete: (err, stmt, rows) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+
+            // Usar streaming si está disponible
+            if (stmt.streamRows) {
+              let firstRow = {};
+              let rowCounter = 0;
+              let isFirstRow = true;
+              const stream = stmt.streamRows();
+
+              stream.on('data', row => {
+                if (isFirstRow) {
+                  firstRow = row;
+                  sheet.columns = this.generateHeader(row);
+                  isFirstRow = false;
+                }
+                sheet.addRow(row).commit();
+                rowCounter++;
+              });
+
+              stream.on('end', async () => {
+                try {
+                  await workbook.commit();
+                  this.prepareEndOptions(firstRow, rowCounter);
+                  this._end(this.endOptions);
+                  connection.destroy();
+                  resolve();
+                } catch (commitError) {
+                  this.error(commitError, connection);
+                  reject(commitError);
+                }
+              });
+
+              stream.on('error', error => {
+                this.error(error, connection);
+                reject(error);
+              });
+            } else {
+              // Fallback sin streaming
+              try {
+                if (rows && rows.length > 0) {
+                  sheet.columns = this.generateHeader(rows[0]);
+                  rows.forEach(row => {
+                    sheet.addRow(row).commit();
+                  });
+                }
+
+                workbook
+                  .commit()
+                  .then(() => {
+                    this.prepareEndOptions(rows[0], rows ? rows.length : 0);
+                    this._end(this.endOptions);
+                    connection.destroy();
+                    resolve();
+                  })
+                  .catch(commitError => {
+                    this.error(commitError, connection);
+                    reject(commitError);
+                  });
+              } catch (fallbackError) {
+                this.error(fallbackError, connection);
+                reject(fallbackError);
+              }
+            }
+          }
+        });
+      });
+    } catch (err) {
+      this.error(err, connection);
+    }
+  }
+
+  async queryToCSV(connection, query, params) {
+    try {
+      // Verificar que el directorio del archivo de exportación existe
+      await fsp.access(path.dirname(params.csvFileExport));
+
+      const fileStreamWriter = fs.createWriteStream(params.csvFileExport);
+
+      const paramsCSV = params.csvOptions || {};
+      if (!paramsCSV.hasOwnProperty('headers')) paramsCSV.headers = true;
+
+      const csvStream = csv.format(paramsCSV).on('error', err => {
+        this.error(err, connection);
+      });
+
+      fileStreamWriter.on('error', error => {
+        this.error(error, connection);
+      });
+
+      return new Promise((resolve, reject) => {
+        connection.execute({
+          sqlText: query,
+          streamResult: true,
+          complete: (err, stmt, rows) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+
+            // Usar streaming si está disponible
+            if (stmt.streamRows) {
+              let firstRow = {};
+              let rowCounter = 0;
+              let isFirstRow = true;
+              const stream = stmt.streamRows();
+
+              stream.on('data', row => {
+                if (isFirstRow) {
+                  firstRow = row;
+                  isFirstRow = false;
+                }
+                rowCounter++;
+              });
+
+              stream.on('end', () => {
+                this.prepareEndOptions(firstRow, rowCounter);
+                this._end(this.endOptions);
+                connection.destroy();
+                resolve();
+              });
+
+              stream.on('error', error => {
+                this.error(error, connection);
+                reject(error);
+              });
+
+              // Pipe los datos a CSV y luego al archivo
+              stream.pipe(csvStream).pipe(fileStreamWriter);
+            } else {
+              // Fallback sin streaming
+              try {
+                if (rows && rows.length > 0) {
+                  rows.forEach(row => {
+                    csvStream.write(row);
+                  });
+                }
+                csvStream.end();
+
+                csvStream.on('finish', () => {
+                  this.prepareEndOptions(rows[0], rows ? rows.length : 0);
+                  this._end(this.endOptions);
+                  connection.destroy();
+                  resolve();
+                });
+              } catch (fallbackError) {
+                this.error(fallbackError, connection);
+                reject(fallbackError);
+              }
+            }
+          }
+        });
+      });
+    } catch (err) {
+      this.error(err, connection);
+    }
+  }
+
+  generateHeader(row) {
+    const headers = [];
+    Object.keys(row).forEach(key => {
+      headers.push({
+        header: key,
+        key: key,
+        width: 20
+      });
+    });
+    return headers;
+  }
+}
+
+module.exports = snowflakeExecutor;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@runnerty/executor-snowflake",
+  "version": "1.0.0",
+  "description": "Runnerty module: Snowflake executor (MVP)",
+  "author": "Coderty",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test-simple.js"
+  },
+  "dependencies": {
+    "@runnerty/module-core": "~3.1.1",
+    "exceljs": "^4.4.0",
+    "jsonstream": "^1.0.3",
+    "snowflake-sdk": "^1.9.0",
+    "fast-csv": "^4.3.6"
+  },
+  "devDependencies": {
+    "eslint": "^8.19.0",
+    "prettier": "^2.7.1"
+  },
+  "keywords": [
+    "runnerty",
+    "executor",
+    "snowflake"
+  ]
+}

package/scaffold/assets/sql/test.sql

@@ -0,0 +1,14 @@
+-- Example SQL file for Snowflake
+SELECT 
+    'Runnerty Snowflake Test' as test_name,
+    CURRENT_TIMESTAMP() as execution_time,
+    CURRENT_USER() as executed_by,
+    CURRENT_DATABASE() as database_name,
+    CURRENT_SCHEMA() as schema_name;
+
+-- Generate some sample data
+SELECT 
+    seq4() as row_number,
+    UNIFORM(1, 100, RANDOM()) as random_number,
+    TO_CHAR(DATEADD(day, seq4(), CURRENT_DATE()), 'YYYY-MM-DD') as future_date
+FROM TABLE(GENERATOR(ROWCOUNT => 3));

package/scaffold/config.json

@@ -0,0 +1,15 @@
+{
+  "executors": [
+    {
+      "id": "snowflake_default",
+      "type": "@runnerty-executor-snowflake",
+      "account": "@ENV(SNOWFLAKE_ACCOUNT)",
+      "username": "@ENV(SNOWFLAKE_USERNAME)",
+      "password": "@ENV(SNOWFLAKE_PASSWORD)",
+      "database": "@ENV(SNOWFLAKE_DATABASE)",
+      "schema": "@ENV(SNOWFLAKE_SCHEMA)",
+      "warehouse": "@ENV(SNOWFLAKE_WAREHOUSE)",
+      "role": "@ENV(SNOWFLAKE_ROLE)"
+    }
+  ]
+}

package/scaffold/plan.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://raw.githubusercontent.com/runnerty/schemas/master/schemas/3.1/plan.json",
+  "chains": [
+    {
+      "id": "CHAIN_SNOWFLAKE_SSO",
+      "name": "SNOWFLAKE SSO Examples",
+      "defaults_processes": {
+        "notifications": {
+          "on_start": [
+            {
+              "id": "console_default",
+              "message": "🚀 START: @GV(PROCESS_ID) - @GETDATE('YYYY-MM-DD HH:mm:ss')"
+            }
+          ],
+          "on_fail": [
+            {
+              "id": "console_default",
+              "message": "❌ ERROR: @GV(PROCESS_ID) - @GV(PROCESS_EXEC_ERR_OUTPUT)",
+              "mode": "error"
+            }
+          ],
+          "on_end": [
+            {
+              "id": "console_default",
+              "message": "✅ END: @GV(PROCESS_ID) - Rows: @GV(PROCESS_EXEC_DB_COUNTROWS) - @GETDATE('YYYY-MM-DD HH:mm:ss')"
+            }
+          ]
+        }
+      },
+      "processes": [
+        {
+          "id": "SNOWFLAKE_SSO_TEST",
+          "name": "Test SSO Connection",
+          "exec": {
+            "id": "snowflake_default",
+            "command": "SELECT CURRENT_TIMESTAMP() as now, CURRENT_USER() as user, CURRENT_DATABASE() as db, CURRENT_SCHEMA() as schema"
+          }
+        },
+        {
+          "id": "SNOWFLAKE_WITH_PARAMS",
+          "name": "Query with Parameters",
+          "exec": {
+            "id": "snowflake_default",
+            "command": "SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = :schema AND TABLE_NAME LIKE :table_pattern LIMIT :limit",
+            "args": {
+              "schema": "'REPORTING_PUB'",
+              "table_pattern": "'%'",
+              "limit": "5"
+            }
+          }
+        },
+        {
+          "id": "SNOWFLAKE_FROM_FILE",
+          "name": "Execute SQL from File",
+          "exec": {
+            "id": "snowflake_default",
+            "command_file": "./sql/example_query.sql"
+          }
+        }
+      ]
+    }
+  ]
+}

package/schema.json

@@ -0,0 +1,112 @@
+{
+  "$schema": "http://json-schema.org/draft-06/schema#",
+  "title": "@runnerty-executor-snowflake",
+  "definitions": {
+    "config": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "type": {
+          "type": "string",
+          "pattern": "@runnerty-executor-snowflake"
+        },
+        "user": {
+          "type": "string"
+        },
+        "password": {
+          "type": "string"
+        },
+        "database": {
+          "type": "string"
+        },
+        "host": {
+          "type": "string"
+        },
+        "port": {
+          "type": "string"
+        },
+        "debug": {
+          "type": "boolean"
+        },
+        "ssl": {
+          "type": "object"
+        },
+        "connectionTimeoutMillis": {
+          "type": "number"
+        },
+        "keepAliveInitialDelayMillis": {
+          "type": "number"
+        },
+        "keepAlive": {
+          "type": "boolean"
+        },
+        "parseInputDatesAsUTC": {
+          "type": "boolean"
+        },
+        "query_timeout": {
+          "type": ["boolean", "number"]
+        },
+        "statement_timeout": {
+          "type": ["boolean", "number"]
+        },
+        "idle_in_transaction_session_timeout": {
+          "type": ["boolean", "number"]
+        },
+        "application_name": {
+          "type": "string"
+        },
+        "encoding": {
+          "type": "string"
+        }
+      }
+    },
+    "params": {
+      "oneOf": [
+        {
+          "type": "object",
+          "required": ["id", "command"],
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "command": {
+              "type": "string"
+            },
+            "args": {
+              "type": "object"
+            },
+            "fileExport": {
+              "type": "string"
+            },
+            "localInFile": {
+              "type": "string"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "required": ["id", "command_file"],
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "command_file": {
+              "type": "string"
+            },
+            "args": {
+              "type": "object"
+            },
+            "fileExport": {
+              "type": "string"
+            },
+            "localInFile": {
+              "type": "string"
+            }
+          }
+        }
+      ]
+    }
+  }
+}