@tachybase/database 0.23.8

package/lib/sql-collection/query-generator.js

@@ -0,0 +1,70 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_generator_exports = {};
+__export(query_generator_exports, {
+  selectQuery: () => selectQuery
+});
+module.exports = __toCommonJS(query_generator_exports);
+var import_utils = require("@tachybase/utils");
+function selectQuery(tableName, options, model) {
+  var _a;
+  options = options || {};
+  if (import_utils.lodash.isEmpty(options)) {
+    return `${model.sql};`;
+  }
+  const queryItems = [];
+  let attributes = options.attributes && options.attributes.slice();
+  if (attributes) {
+    const fields = Array.from(((_a = model.collection) == null ? void 0 : _a.fields.keys()) || []);
+    attributes = attributes.filter((attr) => attr === "*" || typeof attr !== "string" || fields.includes(attr));
+  }
+  attributes = this.escapeAttributes(attributes, { model });
+  attributes = attributes || ["*"];
+  if (Object.prototype.hasOwnProperty.call(options, "where")) {
+    options.where = this.getWhereConditions(options.where, tableName, model, options);
+    if (options.where) {
+      queryItems.push(` WHERE ${options.where}`);
+    }
+  }
+  if (options.group) {
+    options.group = Array.isArray(options.group) ? options.group.map((t) => this.aliasGrouping(t, model, tableName, options)).join(", ") : this.aliasGrouping(options.group, model, tableName, options);
+    if (options.group) {
+      queryItems.push(` GROUP BY ${options.group}`);
+    }
+  }
+  if (options.order) {
+    const orders = this.getQueryOrders(options, model, false);
+    if (orders.mainQueryOrder.length) {
+      queryItems.push(` ORDER BY ${orders.mainQueryOrder.join(", ")}`);
+    }
+  }
+  const limitOrder = this.addLimitAndOffset(options, model);
+  if (limitOrder) {
+    queryItems.push(limitOrder);
+  }
+  const query = `SELECT ${attributes.join(", ")} FROM (${model.sql}) ${this.getAliasToken()} ${this.quoteIdentifier(
+    model.name
+  )}${queryItems.join("")}`;
+  return `${query};`;
+}
+__name(selectQuery, "selectQuery");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectQuery
+});

package/lib/sql-collection/sql-collection.d.ts

@@ -0,0 +1,7 @@
+import { Collection, CollectionContext, CollectionOptions } from '../collection';
+export declare class SqlCollection extends Collection {
+    constructor(options: CollectionOptions, context: CollectionContext);
+    isSql(): boolean;
+    collectionSchema(): any;
+    modelInit(): void;
+}

package/lib/sql-collection/sql-collection.js

@@ -0,0 +1,69 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sql_collection_exports = {};
+__export(sql_collection_exports, {
+  SqlCollection: () => SqlCollection
+});
+module.exports = __toCommonJS(sql_collection_exports);
+var import_collection = require("../collection");
+var import_sql_model = require("./sql-model");
+const _SqlCollection = class _SqlCollection extends import_collection.Collection {
+  constructor(options, context) {
+    options.autoGenId = false;
+    options.timestamps = false;
+    options.underscored = false;
+    super(options, context);
+  }
+  isSql() {
+    return true;
+  }
+  collectionSchema() {
+    return void 0;
+  }
+  modelInit() {
+    var _a;
+    const { autoGenId, sql } = this.options;
+    const model = (_a = class extends import_sql_model.SQLModel {
+    }, __name(_a, "model"), _a);
+    model.init(null, {
+      ...this.sequelizeModelOptions(),
+      schema: void 0
+    });
+    if (!autoGenId) {
+      model.removeAttribute("id");
+    }
+    model.sql = sql;
+    model.database = this.context.database;
+    model.collection = this;
+    this.model = new Proxy(model, {
+      get(target, prop) {
+        if (prop === "_schema") {
+          return void 0;
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  }
+};
+__name(_SqlCollection, "SqlCollection");
+let SqlCollection = _SqlCollection;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SqlCollection
+});

package/lib/sql-collection/sql-model.d.ts

@@ -0,0 +1,16 @@
+import { Model } from '../model';
+export declare class SQLModel extends Model {
+    static sql: string;
+    static get queryInterface(): import("sequelize").QueryInterface;
+    static sync(): Promise<any>;
+    private static parseTablesAndColumns;
+    private static getTableNameWithSchema;
+    static inferFields(): {
+        [field: string]: {
+            type: string;
+            source: string;
+            collection: string;
+            interface: string;
+        };
+    };
+}

package/lib/sql-collection/sql-model.js

@@ -0,0 +1,168 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var sql_model_exports = {};
+__export(sql_model_exports, {
+  SQLModel: () => SQLModel
+});
+module.exports = __toCommonJS(sql_model_exports);
+var import_model = require("../model");
+var import_sql_parser = __toESM(require("../sql-parser"));
+var import_query_generator = require("./query-generator");
+const _SQLModel = class _SQLModel extends import_model.Model {
+  static get queryInterface() {
+    const queryInterface = this.sequelize.getQueryInterface();
+    const queryGenerator = queryInterface.queryGenerator;
+    const sqlGenerator = new Proxy(queryGenerator, {
+      get(target, prop) {
+        if (prop === "selectQuery") {
+          return import_query_generator.selectQuery.bind(target);
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+    return new Proxy(queryInterface, {
+      get(target, prop) {
+        if (prop === "queryGenerator") {
+          return sqlGenerator;
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  }
+  static async sync() {
+  }
+  static parseTablesAndColumns() {
+    let { ast } = import_sql_parser.default.parse(this.sql);
+    if (Array.isArray(ast)) {
+      ast = ast[0];
+    }
+    if (ast.with) {
+      const tables = /* @__PURE__ */ new Set();
+      ast.with.forEach((withItem) => {
+        const tableList = withItem.tableList;
+        tableList.forEach((table) => {
+          const name = table.split("::")[2];
+          tables.add(name);
+        });
+      });
+      return Array.from(tables).map((table) => ({ table, columns: "*" }));
+    }
+    if (ast.columns === "*") {
+      return ast.from.map((fromItem) => ({
+        table: fromItem.table,
+        columns: "*"
+      }));
+    }
+    const columns = ast.columns.reduce(
+      (tableMp, column) => {
+        if (column.expr.type !== "column_ref") {
+          return tableMp;
+        }
+        const table = column.expr.table;
+        const columnAttr = { name: column.expr.column, as: column.as };
+        if (!tableMp[table]) {
+          tableMp[table] = [columnAttr];
+        } else {
+          tableMp[table].push(columnAttr);
+        }
+        return tableMp;
+      },
+      {}
+    );
+    ast.from.forEach((fromItem) => {
+      if (columns[fromItem.as]) {
+        columns[fromItem.table] = columns[fromItem.as];
+        columns[fromItem.as] = void 0;
+      }
+    });
+    return Object.entries(columns).filter(([_, columns2]) => columns2).map(([table, columns2]) => ({ table, columns: columns2 }));
+  }
+  static getTableNameWithSchema(table) {
+    if (this.database.inDialect("postgres") && !table.includes(".")) {
+      return `public.${table}`;
+    }
+    return table;
+  }
+  static inferFields() {
+    const tables = this.parseTablesAndColumns();
+    const fields = tables.reduce((fields2, { table, columns }) => {
+      const tableName = this.getTableNameWithSchema(table);
+      const collection = this.database.tableNameCollectionMap.get(tableName);
+      if (!collection) {
+        return fields2;
+      }
+      const attributes = collection.model.getAttributes();
+      const sourceFields = {};
+      if (columns === "*") {
+        Object.values(attributes).forEach((attribute) => {
+          const field = collection.getField(attribute.fieldName);
+          if (!(field == null ? void 0 : field.options.interface)) {
+            return;
+          }
+          sourceFields[field.name] = {
+            collection: field.collection.name,
+            type: field.type,
+            source: `${field.collection.name}.${field.name}`,
+            interface: field.options.interface,
+            uiSchema: field.options.uiSchema
+          };
+        });
+      } else {
+        columns.forEach((column) => {
+          const modelField = Object.values(attributes).find((attribute) => attribute.field === column.name);
+          if (!modelField) {
+            return;
+          }
+          const field = collection.getField(modelField.fieldName);
+          if (!(field == null ? void 0 : field.options.interface)) {
+            return;
+          }
+          sourceFields[column.as || column.name] = {
+            collection: field.collection.name,
+            type: field.type,
+            source: `${field.collection.name}.${field.name}`,
+            interface: field.options.interface,
+            uiSchema: field.options.uiSchema
+          };
+        });
+      }
+      return { ...fields2, ...sourceFields };
+    }, {});
+    return fields;
+  }
+};
+__name(_SQLModel, "SQLModel");
+__publicField(_SQLModel, "sql");
+let SQLModel = _SQLModel;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SQLModel
+});

package/lib/sql-parser/index.d.ts

@@ -0,0 +1,10 @@
+declare function peg$SyntaxError(message: any, expected: any, found: any, location: any): any;
+declare class peg$SyntaxError {
+    constructor(message: any, expected: any, found: any, location: any);
+    format(sources: any): string;
+}
+declare namespace peg$SyntaxError {
+    function buildMessage(expected: any, found: any): string;
+}
+declare function peg$parse(input: any, options: any): any;
+export { peg$SyntaxError as SyntaxError, peg$parse as parse };