rads-db 3.1.16 → 3.2.0

package/drivers/sql.cjs

@@ -0,0 +1,848 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _lodash = _interopRequireDefault(require("lodash"));
+var _mssql = _interopRequireDefault(require("mssql"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const cache = {};
+const idType = "VARCHAR(128)";
+const strType = "VARCHAR(MAX)";
+const numberType = "DECIMAL(30,15)";
+const booleanType = "BIT";
+const simpleSubclauseRegex = /^[a-z0-9_@]+.[a-z0-9_@]+ = [a-z0-9_@.]+$/i;
+const sanitizePathRegex = /^[a-z0-9_\[\]\.]+$/i;
+const operatorHandlers = {
+  some: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramNamePrefix,
+      paramName,
+      whereVal
+    } = whereArgs;
+    const subClause = getSqlWhere(ctx, parameters, whereVal, `${name}.`, `${paramNamePrefix}${paramName}_`);
+    if (subClause) {
+      if (simpleSubclauseRegex.test(subClause)) {
+        const parts = subClause.split(" ");
+        const field = parts[0];
+        const variable = parts[2];
+        return `array_contains(${namePrefix}${name}, { ${field.split(".")[1]}: ${variable} }, true)`;
+      }
+      return `exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
+    }
+    return `array_length(${namePrefix}${name}) > 0`;
+  },
+  none: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramNamePrefix,
+      paramName,
+      whereVal
+    } = whereArgs;
+    const subClause = getSqlWhere(ctx, parameters, whereVal, `${name}.`, `${paramNamePrefix}${paramName}_`);
+    if (subClause) return `not exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
+    return `array_length(${namePrefix}${name}) = 0`;
+  },
+  and: (ctx, parameters, whereArgs) => {
+    const {
+      namePrefix,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    if (!_lodash.default.isArray(whereVal)) throw new Error(`Value for where._and must be an array`);
+    const clauses = [];
+    for (let i = 0; i < whereVal.length; i++) {
+      const andQuery = getSqlWhere(ctx, parameters, whereVal[i], namePrefix, `${paramNamePrefix}and${i}_`);
+      clauses.push(andQuery);
+    }
+    if (!clauses.length) return null;
+    return `((${clauses.join(") and (")}))`;
+  },
+  not: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const subClause = getSqlWhere(ctx, parameters, whereVal, `${namePrefix}${name}`, `${paramNamePrefix}not_`);
+    if (!subClause) return null;
+    return `not(${subClause})`;
+  },
+  or: (ctx, parameters, whereArgs) => {
+    const {
+      namePrefix,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    if (!_lodash.default.isArray(whereVal)) throw new Error(`Value for where._or must be an array`);
+    const clauses = [];
+    for (let i = 0; i < whereVal.length; i++) {
+      const orQuery = getSqlWhere(ctx, parameters, whereVal[i], namePrefix, `${paramNamePrefix}or${i}_`);
+      clauses.push(orQuery);
+    }
+    if (!clauses.length) return null;
+    return `((${clauses.join(") or (")}))`;
+  },
+  isNull: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      whereVal
+    } = whereArgs;
+    const n = `${namePrefix}${name}`;
+    if (whereVal) return `${n} is null`;
+    return `${n} is not null`;
+  },
+  eq: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} = @${pn}`;
+  },
+  in: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    const inStrs = [];
+    for (const [i, v] of whereVal.entries()) {
+      parameters[`${pn}_${i}`] = v;
+      inStrs.push(`@${pn}_${i}`);
+    }
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} IN (${inStrs.join(", ")})`;
+  },
+  startsWith: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} COLLATE Latin1_General_CS_AS LIKE @${pn} + '%'`;
+  },
+  istartsWith: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} LIKE @${pn} + '%'`;
+  },
+  endsWith: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} COLLATE Latin1_General_CS_AS LIKE '%' + @${pn}`;
+  },
+  iendsWith: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} LIKE '%' + @${pn}`;
+  },
+  contains: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} COLLATE Latin1_General_CS_AS LIKE '%' + @${pn} + '%'`;
+  },
+  icontains: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} LIKE '%' + @${pn} + '%'`;
+  },
+  arrayContains: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `@${pn} IN ${namePrefix}${name}`;
+  },
+  isEmpty: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      whereVal
+    } = whereArgs;
+    const n = `${namePrefix}${name}`;
+    if (whereVal) return `${n} is null`;
+    return `${n} is not null`;
+  },
+  jsonContains: (ctx, parameters, whereArgs) => {
+    throw new Error("jsonContains operator is not supported in SQL driver yet");
+  },
+  ieq: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} != @${pn}`;
+  },
+  gt: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} > @${pn}`;
+  },
+  gte: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} >= @${pn}`;
+  },
+  lt: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} < @${pn}`;
+  },
+  lte: (ctx, parameters, whereArgs) => {
+    const {
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix,
+      whereVal
+    } = whereArgs;
+    const pn = `${paramNamePrefix}${paramName}`;
+    parameters[pn] = whereVal;
+    return `${namePrefix}${name} <= @${pn}`;
+  }
+};
+var _default = options => {
+  let client;
+  let clientPromise;
+  let introspection;
+  let introspectionPromise;
+  options = {
+    tablePrefix: "dbo.",
+    stagingTablePrefix: "dbo_stg.",
+    ...options
+  };
+  if (options.tablePrefix === options.stagingTablePrefix) {
+    throw new Error("Table prefix and staging table prefix cannot be the same");
+  }
+  return (schema, entity) => {
+    const result = {
+      driverName: "sql",
+      get client() {
+        return client;
+      },
+      getMany,
+      async getAgg(args, ctx) {
+        args = args || {};
+        const {
+          query,
+          parameters
+        } = getSqlQuery(schema, entity, args, options);
+        const req = client.request();
+        for (const p in parameters) {
+          req.input(p, parameters[p]);
+        }
+        console.log(query);
+        const result2 = await req.query(query);
+        const nodes = result2.recordset || [];
+        console.log(result2);
+        return nodes[0];
+      },
+      async putMany(items, ctx) {
+        await ensureClientConnected();
+        const realTablePrefix = options.tablePrefix || "";
+        const stagingTablePrefix = options.stagingTablePrefix || "";
+        const sqlTables = getSqlTablesFor(entity);
+        for (const st of sqlTables) {
+          const request = client.request();
+          const columns = Object.keys(st.tableColumns);
+          const stagingTable = `${stagingTablePrefix || ""}${st.tableName}`;
+          const realTable = `${realTablePrefix || ""}${st.tableName}`;
+          const columnNames = columns.join(", ");
+          const valueStrs = [];
+          for (const row of items) {
+            const rowsToInsert = st.getValue ? st.getValue(row) || [] : [row];
+            for (let j = 0; j < rowsToInsert.length; j++) {
+              const rowToInsert = rowsToInsert[j];
+              const paramNames = [];
+              for (const columnName in st.tableColumns) {
+                paramNames.push(stringifyValueForInsert(st.tableColumns[columnName].getValue(rowToInsert, row, j)));
+              }
+              valueStrs.push(`(${paramNames.join(", ")})`);
+            }
+          }
+          for (const valuesChunk of _lodash.default.chunk(valueStrs, 1e3)) {
+            if (valuesChunk.length) {
+              const insertQuery = `TRUNCATE TABLE ${stagingTable}; INSERT INTO ${stagingTable} (${columnNames}) VALUES ${valuesChunk.join(",\n")}`;
+              try {
+                await request.query(insertQuery);
+                await client.request().query(`
+                  UPDATE tgt
+                  SET ${columns.map(c => `tgt.${c} = src.${c}`).join(",\n")}
+                  FROM ${realTable} tgt
+                  JOIN ${stagingTable} src ON tgt.id = src.id;
+              
+                  INSERT INTO ${realTable} (${columns.join(", ")})
+                  SELECT ${columns.map(c => `src.${c}`).join(", ")}
+                  FROM ${stagingTable} src
+                  WHERE NOT EXISTS (
+                    SELECT 1 FROM ${realTable} tgt WHERE tgt.id = src.id
+                  );
+
+                `);
+              } catch (e) {
+                console.error(`\u274C Failed insert into ${realTable} [${valuesChunk.length} rows]`);
+                console.error(`First 300 chars of query:
+${insertQuery.slice(0, 300)}...`);
+                throw e;
+              }
+            }
+          }
+        }
+      },
+      async deleteAll() {
+        await ensureClientConnected();
+        await client.query(`delete from ${entity}`);
+        return [];
+      },
+      /** Generates migration script for this one entity */
+      async generateMigrationScript() {
+        await ensureIntrospectionIsAvailable();
+        return buildMigrationScript(schema, entity);
+        function buildMigrationScript(schema2, entityName) {
+          const entity2 = schema2[entityName];
+          if (!entity2) throw new Error(`Entity "${entityName}" not found in schema`);
+          const createTableRequest1 = getCreateTableRequestsFor(entityName, {
+            tableNamePrefix: options.tablePrefix
+          });
+          const createTableRequest2 = getCreateTableRequestsFor(entityName, {
+            tableNamePrefix: options.stagingTablePrefix
+          });
+          return [...createTableRequest1.createRequests, ...createTableRequest2.createRequests].join(";\n\n");
+        }
+        function getCreateTableRequestsFor(entityName, options2) {
+          const {
+            tableNameSuffix,
+            tableNamePrefix,
+            dropIfExists,
+            addPrimaryKey,
+            addForeignKeys,
+            foreignKeysTables
+          } = options2 || {};
+          const sqlTables = getSqlTablesFor(entityName);
+          const dropRequests = [];
+          const createRequests = [];
+          const pkRequests = [];
+          const fkRequests = [];
+          const schema2 = tableNamePrefix?.split(".")[0];
+          if (schema2) {
+            createRequests.push(`IF NOT EXISTS (SELECT 1 FROM sys.schemas WHERE name = N'${schema2}') BEGIN EXEC('CREATE SCHEMA ${schema2}') END`);
+          }
+          for (const st of sqlTables) {
+            const tableName = (tableNamePrefix || "") + st.tableName + (tableNameSuffix || "");
+            const columnStrs = buildColumnStrs(st.tableColumns);
+            const columnsStr = columnStrs.map(x => x.replace("ADD ", "")).join(", \n");
+            if (dropIfExists) {
+              dropRequests.push(`IF OBJECT_ID('${tableName}', 'U') IS NOT NULL BEGIN DROP TABLE ${tableName} END`);
+            }
+            createRequests.push(`IF OBJECT_ID('${tableName}', 'U') IS NULL BEGIN CREATE TABLE ${tableName} (${columnsStr}) END`);
+            if (addPrimaryKey) {
+              const primaryKeyColumns = Object.keys(st.tableColumns).filter(c => st.tableColumns[c].isPrimaryKey);
+              if (primaryKeyColumns.length) {
+                pkRequests.push(getAddPrimaryKeySql(tableName, primaryKeyColumns[0]));
+              }
+            }
+            if (addForeignKeys) {
+              for (const columnName in st.tableColumns) {
+                const column = st.tableColumns[columnName];
+                if (column.isForeignKeyFor) {
+                  const foreignTableName = column.isForeignKeyFor;
+                  if (foreignKeysTables && !foreignKeysTables.includes(foreignTableName)) {
+                    console.warn(`Skipping foreign key for ${foreignTableName}`);
+                    continue;
+                  }
+                  if ((tableNamePrefix || "") + foreignTableName === tableName) {
+                    console.warn(`Skipping foreign key for ${foreignTableName} because it is same as source table`);
+                    continue;
+                  }
+                  if (["tcUserCreatedBy_id", "tcUserUpdatedBy_id", "tcUserCreatedByApp_id", "tcUserUpdatedByApp_id", "tcAccountManufacturer_id"].includes(columnName)) {
+                    continue;
+                  }
+                  const foreignColumnName = `id`;
+                  fkRequests.push(getAddForeignKeySql(tableName, column.name, (tableNamePrefix || "") + foreignTableName, foreignColumnName));
+                }
+              }
+            }
+          }
+          return {
+            createRequests,
+            pkRequests,
+            fkRequests,
+            dropRequests
+          };
+        }
+        function getAddPrimaryKeySql(tableName, columnName) {
+          let schema2 = tableName.split(".")[0] || "";
+          if (schema2) schema2 += ".";
+          const constraintName = `PK_${tableName.replaceAll(".", "_")}_${columnName}`;
+          return `
+IF OBJECT_ID('${schema2}${constraintName}', 'PK') IS NULL
+BEGIN
+    ALTER TABLE ${tableName}
+    ADD CONSTRAINT ${constraintName}
+    PRIMARY KEY NONCLUSTERED(${columnName}) NOT ENFORCED;
+END;
+  `.trim();
+        }
+        function getAddForeignKeySql(tableName, columnName, foreignTableName, foreignColumnName) {
+          let schema2 = tableName.split(".")[0] || "";
+          if (schema2) schema2 += ".";
+          const constraintName = `FK_${tableName.replaceAll(".", "_")}_${columnName}`;
+          return `
+IF OBJECT_ID('${schema2}${constraintName}', 'F') IS NULL
+BEGIN
+    ALTER TABLE ${tableName}
+    ADD CONSTRAINT ${constraintName}
+    FOREIGN KEY (${columnName})
+    REFERENCES ${foreignTableName} (${foreignColumnName}) NOT ENFORCED;
+END;
+  `.trim();
+        }
+        function buildColumnStrs(tableColumns) {
+          const columns = [];
+          for (const fieldName in tableColumns) {
+            const field = tableColumns[fieldName];
+            columns.push(`ADD "${field.name}" ${field.type} ${field.isPrimaryKey ? "NOT NULL" : "NULL"}`);
+          }
+          return columns;
+        }
+      }
+    };
+    function getSqlTablesFor(entityName) {
+      return cache[entityName] || (cache[entityName] = getSqlTablesForEntityInner(entityName));
+    }
+    function getSqlTablesForEntityInner(entityName) {
+      const entitySchema = schema[entityName];
+      if (!entitySchema || !entitySchema.fields) {
+        throw new Error(`Entity ${entityName} not found in schema`);
+      }
+      const tableColumns = {};
+      const nestedArrayTables = [];
+      for (const fieldName in entitySchema.fields) {
+        const field = entitySchema.fields[fieldName];
+        if (!field || field.decorators?.deprecated || field.comment?.includes("@deprecated") || field.name === "beforeChange") {
+          continue;
+        }
+        if (field.isArray) {
+          const nts = getNestedArrayTables(field, entityName) || [];
+          nestedArrayTables.push(...nts);
+          continue;
+        }
+        if (field.isRelation) {
+          const adjustedFieldName = `${fieldName}_id`;
+          tableColumns[adjustedFieldName] = {
+            name: adjustedFieldName,
+            type: idType,
+            description: field.comment,
+            isRequired: field.isRequired,
+            isForeignKeyFor: field.type,
+            getValue: row => row[field.name]?.id
+          };
+          continue;
+        }
+        if (schema[field.type]?.fields) {
+          const [nestedObjectTable, ...nestedObjectArrayTables] = getSqlTablesForEntityInner(field.type);
+          for (const columnName in nestedObjectTable.tableColumns) {
+            if (field.isChange && columnName === "id") continue;
+            const column = nestedObjectTable.tableColumns[columnName];
+            const newColumnName = `${fieldName}_${column.name}`;
+            tableColumns[newColumnName] = {
+              ...column,
+              isPrimaryKey: void 0,
+              name: newColumnName,
+              getValue: (row, entity2, index) => row[field.name] && column.getValue(row[field.name], entity2, index)
+            };
+          }
+          for (const at of nestedObjectArrayTables) {
+            nestedArrayTables.push({
+              ...at,
+              tableName: `${entityName}_${fieldName}_${at.tableName.split("_").slice(1).join("_")}`,
+              getValue: row => row[field.name] && at.getValue?.(row[field.name]),
+              tableColumns: at.tableColumns
+            });
+          }
+          continue;
+        }
+        const sqlType = getSqlType(field);
+        if (!sqlType) continue;
+        tableColumns[fieldName] = {
+          name: field.name,
+          type: sqlType,
+          description: field.comment,
+          isRequired: field.isRequired,
+          isPrimaryKey: fieldName === "id",
+          getValue: row => row[field.name]
+        };
+      }
+      return [{
+        tableName: entityName,
+        description: entitySchema.comment,
+        tableColumns
+      }, ...nestedArrayTables];
+    }
+    function getNestedArrayTables(field, entityName) {
+      const result2 = [];
+      const entityReferenceColumnName = `${_lodash.default.lowerFirst(entityName)}_id`;
+      const commonTableColumns = {
+        id: {
+          name: "id",
+          type: idType,
+          isRequired: true,
+          isPrimaryKey: true,
+          getValue: (row, entity2, index) => `${entity2.id}_${index}`
+        },
+        [entityReferenceColumnName]: {
+          name: entityReferenceColumnName,
+          type: idType,
+          isForeignKeyFor: entityName,
+          isRequired: true,
+          getValue: (row, entity2) => entity2.id
+        }
+      };
+      if (schema[field.type]?.fields) {
+        if (!field.isRelation) {
+          const [objectTable, ...objectArrayTables] = getSqlTablesForEntityInner(field.type);
+          if (objectArrayTables.length) {
+            console.warn("Nested array tables are not supported yet", entityName, field.name);
+          }
+          result2.push({
+            tableName: `${entityName}_${field.name}`,
+            description: field.comment,
+            getValue: row => row[field.name] || [],
+            tableColumns: {
+              ...commonTableColumns,
+              ...objectTable.tableColumns
+            }
+          });
+        } else {
+          result2.push({
+            tableName: `${entityName}_${field.name}`,
+            description: field.comment,
+            getValue: row => row[field.name] || [],
+            tableColumns: {
+              ...commonTableColumns,
+              val_id: {
+                name: "val_id",
+                type: idType,
+                isRequired: true,
+                getValue: (row, entity2) => row?.id
+              }
+            }
+          });
+        }
+      } else {
+        const sqlType = getSqlType(field);
+        if (!sqlType) return [];
+        result2.push({
+          tableName: `${entityName}_${field.name}`,
+          description: field.comment,
+          getValue: row => row[field.name] || [],
+          tableColumns: {
+            ...commonTableColumns,
+            val: {
+              name: "val",
+              type: sqlType,
+              isRequired: true,
+              getValue: (row, entity2) => row
+            }
+          }
+        });
+      }
+      return result2;
+    }
+    function getSqlType(field) {
+      if (field.type === "string" && field.name === "id") return idType;
+      if (field.type === "string") return strType;
+      if (field.type === "number") return numberType;
+      if (field.type === "boolean") return booleanType;
+      if (schema[field.type]?.enumValues) {
+        return idType;
+      }
+      if (field.type === "Record<string, any>") {
+        return strType;
+      }
+      console.warn("Unknown type", field.type);
+    }
+    async function getMany(args, ctx) {
+      await ensureClientConnected();
+      args = args || {};
+      const maxItemCount = args.maxItemCount || 1e3;
+      const {
+        query,
+        parameters
+      } = getSqlQuery(schema, entity, args, options);
+      const req = client.request();
+      for (const p in parameters) {
+        req.input(p, parameters[p]);
+      }
+      console.log(query);
+      const result2 = await req.query(query);
+      const nodes = result2.recordset || [];
+      console.log(result2);
+      return {
+        nodes,
+        cursor: nodes.length === maxItemCount ? String((Number(args.cursor || "0") || 0) + nodes.length) : void 0
+      };
+    }
+    return result;
+  };
+  async function ensureIntrospectionIsAvailable() {
+    if (introspection) return;
+    if (!introspectionPromise) introspectionPromise = ensureIntrospectionIsAvailableInner();
+    await introspectionPromise;
+  }
+  async function ensureIntrospectionIsAvailableInner() {
+    await ensureClientConnected();
+    const response = await client.query(`
+      SELECT * FROM INFORMATION_SCHEMA.TABLES;
+      SELECT * FROM INFORMATION_SCHEMA.COLUMNS;
+    `);
+    if (!_lodash.default.isArray(response.recordsets)) {
+      throw new TypeError("Invalid result");
+    }
+    const tableRows = response.recordsets[0];
+    const columnRows = response.recordsets[1];
+    const result = {};
+    for (const tr of tableRows) {
+      if (tr.TABLE_SCHEMA !== "dbo") continue;
+      const tableName = tr.TABLE_NAME;
+      const columns = columnRows.filter(x => x.TABLE_NAME === tableName);
+      const type = {
+        tableName,
+        tableColumns: {},
+        nestedArrayTables: []
+      };
+      for (const cr of columns) {
+        const fieldName = cr.COLUMN_NAME;
+        const fieldType = cr.DATA_TYPE;
+        const isNullable = cr.IS_NULLABLE === "YES";
+        type.tableColumns[fieldName] = {
+          name: fieldName,
+          type: fieldType,
+          isRequired: !isNullable,
+          getValue: row => row[fieldName]
+        };
+      }
+      result[tableName] = type;
+    }
+    introspection = result;
+  }
+  async function ensureClientConnected() {
+    if (client) return;
+    if (!clientPromise) clientPromise = ensureClientConnectedInner();
+    await clientPromise;
+  }
+  async function ensureClientConnectedInner() {
+    client = await _mssql.default.connect({
+      authentication: options.authentication,
+      server: options.server,
+      database: options.database,
+      ...options.options
+    });
+  }
+};
+module.exports = _default;
+function stringifyValueForInsert(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+  if (typeof value === "number") return value.toString();
+  if (typeof value === "boolean") return value ? "1" : "0";
+  throw new Error(`Unsupported value type: ${typeof value} for value: ${value}`);
+}
+function getSqlQuery(schema, entity, args, options) {
+  args = args || {};
+  const where = args.where || {};
+  const parameters = {};
+  const whereClauses = [getSqlWhere({
+    schema,
+    entity
+  }, parameters, where)].filter(x => x);
+  const orderByClause = getSqlOrderBy(args);
+  let columns = "*";
+  if (args.agg) {
+    const columnsArray = [];
+    for (const key of args.agg) {
+      const [field, aggOp] = key.split("_");
+      if (aggOp === "count") {
+        columnsArray.push("COUNT(1) AS _count");
+      }
+      if (aggOp === "max" && field) {
+        columnsArray.push(`MAX(r.[${field}]) AS ${field}_max`);
+      }
+      if (aggOp === "min" && field) {
+        columnsArray.push(`MIN(r.[${field}]) AS ${field}_min`);
+      }
+      if (aggOp === "sum" && field) {
+        columnsArray.push(`SUM(r.[${field}]) AS ${field}_sum`);
+      }
+    }
+    if (columnsArray.length) {
+      columns = columnsArray.join(", ");
+    }
+  }
+  const maxItemCount = args.maxItemCount || 1e3;
+  const cursor = args.cursor || "0";
+  const paginationClause = args.agg ? "" : `OFFSET ${cursor} ROWS FETCH NEXT ${maxItemCount} ROWS ONLY`;
+  const query = `select ${columns} from ${options.tablePrefix || ""}${entity} as r ${whereClauses.length ? `where ${whereClauses.join(" AND ")}` : ""} ${orderByClause} ${paginationClause}`;
+  return {
+    query,
+    parameters
+  };
+}
+function getSqlOrderBy(args) {
+  let orderByClause = args.agg ? "" : "order by r.id asc";
+  if (args.orderByArray) {
+    orderByClause = `order by `;
+    const orderByColumns = [];
+    for (const order of args.orderByArray) {
+      orderByColumns.push(parseOrderBy(order));
+    }
+    orderByClause = orderByClause + orderByColumns.join(",");
+  } else if (args.orderBy) {
+    orderByClause = `order by ${parseOrderBy(args.orderBy)}`;
+  }
+  return orderByClause;
+}
+function parseOrderBy(order) {
+  const orderByParts = order.split("_");
+  const orderPropFromOrderBy = orderByParts.slice(0, -1).join(".");
+  const orderDirection = orderByParts.at(-1);
+  const orderProp = orderPropFromOrderBy === "value" ? `r.[value]` : `r.${orderPropFromOrderBy}`;
+  const ordr = `${orderProp} ${orderDirection}`;
+  return ordr;
+}
+function getSqlWhere(ctx, parameters, where, namePrefix = "r.", paramNamePrefix = "") {
+  const whereClauses = [];
+  for (const key in where) {
+    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
+    let name = nameFromWhere;
+    if (name === "value") {
+      name = `[${name}]`;
+    }
+    const paramName = key;
+    const whereVal = where[key];
+    if (whereVal == null) continue;
+    const f = getSqlWhereInner({
+      ...ctx,
+      field: nameFromWhere
+    }, parameters, {
+      operator,
+      whereVal,
+      name,
+      namePrefix,
+      paramName,
+      paramNamePrefix
+    });
+    if (f) whereClauses.push(f);
+  }
+  return whereClauses.join(" AND ");
+}
+function getWhereNameOperatorPair(whereKey) {
+  if (whereKey.startsWith("_type")) {
+    const operator = whereKey.split("_")[2];
+    return ["_type", operator];
+  }
+  return whereKey.split("_");
+}
+function getSqlWhereInner(ctx, parameters, whereArgs) {
+  const {
+    operator,
+    whereVal,
+    name,
+    namePrefix,
+    paramName,
+    paramNamePrefix
+  } = whereArgs;
+  if (!operator && _lodash.default.isObject(whereVal)) {
+    return getSqlWhere(ctx, parameters, whereVal, `${namePrefix}${name}.`, `${paramNamePrefix}${paramName}_`);
+  }
+  const fn = operatorHandlers[operator || "eq"];
+  if (!fn) {
+    console.warn(`Unsupported operator: "${operator}"`);
+    return null;
+  }
+  return fn(ctx, parameters, whereArgs);
+}