@tachybase/database 0.23.8

package/lib/options-parser.js

@@ -0,0 +1,332 @@
+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 __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 options_parser_exports = {};
+__export(options_parser_exports, {
+  OptionsParser: () => OptionsParser
+});
+module.exports = __toCommonJS(options_parser_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_qs = __toESM(require("qs"));
+var import_sequelize = require("sequelize");
+var import_filter_parser = __toESM(require("./filter-parser"));
+const debug = require("debug")("noco-database");
+const _OptionsParser = class _OptionsParser {
+  options;
+  database;
+  collection;
+  model;
+  filterParser;
+  context;
+  constructor(options, context) {
+    const { collection } = context;
+    this.collection = collection;
+    this.model = collection.model;
+    this.options = options;
+    this.database = collection.context.database;
+    this.filterParser = new import_filter_parser.default(options == null ? void 0 : options.filter, {
+      collection,
+      app: {
+        ctx: options == null ? void 0 : options.context
+      }
+    });
+    this.context = context;
+  }
+  static appendInheritInspectAttribute(include, collection) {
+    if (include.find((item) => (item == null ? void 0 : item[1]) === "__tableName")) {
+      return;
+    }
+    include.push([
+      import_sequelize.Sequelize.literal(`(select relname from pg_class where pg_class.oid = "${collection.name}".tableoid)`),
+      "__tableName"
+    ]);
+    include.push([
+      import_sequelize.Sequelize.literal(`
+        (SELECT n.nspname
+        FROM pg_class c
+               JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.oid = "${collection.name}".tableoid)
+      `),
+      "__schemaName"
+    ]);
+  }
+  isAssociation(key) {
+    return this.model.associations[key] !== void 0;
+  }
+  isAssociationPath(path) {
+    return this.isAssociation(path.split(".")[0]);
+  }
+  toSequelizeParams() {
+    var _a, _b;
+    const queryParams = this.filterParser.toSequelizeParams();
+    if ((_a = this.options) == null ? void 0 : _a.filterByTk) {
+      queryParams.where = {
+        [import_sequelize.Op.and]: [
+          queryParams.where,
+          {
+            [this.context.targetKey || this.collection.filterTargetKey]: this.options.filterByTk
+          }
+        ]
+      };
+    }
+    if ((_b = this.options) == null ? void 0 : _b.include) {
+      if (!queryParams.include) {
+        queryParams.include = [];
+      }
+      queryParams.include.push(...import_lodash.default.castArray(this.options.include));
+    }
+    return this.parseSort(this.parseFields(queryParams));
+  }
+  /**
+   * parser sort options
+   * @param filterParams
+   * @protected
+   */
+  parseSort(filterParams) {
+    var _a;
+    let sort = ((_a = this.options) == null ? void 0 : _a.sort) || [];
+    if (typeof sort === "string") {
+      sort = sort.split(",");
+    }
+    const orderParams = [];
+    for (const sortKey of sort) {
+      let direction = sortKey.startsWith("-") ? "DESC" : "ASC";
+      const sortField = sortKey.replace("-", "").split(".");
+      if (this.database.inDialect("postgres", "sqlite")) {
+        direction = `${direction} NULLS LAST`;
+      }
+      if (sortField.length > 1) {
+        let associationModel = this.model;
+        for (let i = 0; i < sortField.length - 1; i++) {
+          const associationKey = sortField[i];
+          sortField[i] = associationModel.associations[associationKey].target;
+          associationModel = sortField[i];
+        }
+      } else {
+        const rawField = this.model.rawAttributes[sortField[0]];
+        sortField[0] = (rawField == null ? void 0 : rawField.field) || sortField[0];
+      }
+      sortField.push(direction);
+      if (this.database.isMySQLCompatibleDialect()) {
+        orderParams.push([import_sequelize.Sequelize.fn("ISNULL", import_sequelize.Sequelize.col(`${this.model.name}.${sortField[0]}`))]);
+      }
+      orderParams.push(sortField);
+    }
+    if (orderParams.length > 0) {
+      return {
+        order: orderParams,
+        ...filterParams
+      };
+    }
+    return filterParams;
+  }
+  parseFields(filterParams) {
+    var _a, _b, _c, _d;
+    const appends = ((_a = this.options) == null ? void 0 : _a.appends) || [];
+    const except = [];
+    if ((_b = this.options) == null ? void 0 : _b.attributes) {
+      return {
+        attributes: this.options.attributes
+      };
+    }
+    let attributes = {
+      include: [],
+      exclude: []
+    };
+    if (this.collection.isParent()) {
+      _OptionsParser.appendInheritInspectAttribute(attributes.include, this.collection);
+    }
+    if ((_c = this.options) == null ? void 0 : _c.fields) {
+      attributes = [];
+      if (this.collection.isParent()) {
+        _OptionsParser.appendInheritInspectAttribute(attributes, this.collection);
+      }
+      for (const field of this.options.fields) {
+        if (this.isAssociationPath(field)) {
+          appends.push(field);
+        } else {
+          attributes.push(field);
+        }
+      }
+    }
+    if ((_d = this.options) == null ? void 0 : _d.except) {
+      for (const exceptKey of this.options.except) {
+        if (this.isAssociationPath(exceptKey)) {
+          except.push(exceptKey);
+        } else {
+          if (Array.isArray(attributes)) continue;
+          attributes.exclude.push(exceptKey);
+        }
+      }
+    }
+    return {
+      attributes,
+      ...this.parseExcept(except, this.parseAppends(appends, filterParams))
+    };
+  }
+  parseExcept(except, filterParams) {
+    if (!except) return filterParams;
+    const setExcept = /* @__PURE__ */ __name((queryParams, except2) => {
+      const exceptPath = except2.split(".");
+      const association = exceptPath[0];
+      const lastLevel = exceptPath.length <= 2;
+      const existIncludeIndex = queryParams["include"].findIndex((include) => include["association"] == association);
+      if (existIncludeIndex == -1) {
+        return;
+      }
+      if (lastLevel) {
+        if (Array.isArray(queryParams["include"][existIncludeIndex]["attributes"])) {
+          return;
+        } else {
+          if (!queryParams["include"][existIncludeIndex]["attributes"]["exclude"]) {
+            queryParams["include"][existIncludeIndex]["attributes"]["exclude"] = [];
+          }
+          queryParams["include"][existIncludeIndex]["attributes"]["exclude"].push(exceptPath[1]);
+        }
+      } else {
+        setExcept(queryParams["include"][existIncludeIndex], exceptPath.filter((_, index) => index !== 0).join("."));
+      }
+    }, "setExcept");
+    for (const exceptKey of except) {
+      setExcept(filterParams, exceptKey);
+    }
+    return filterParams;
+  }
+  parseAppendWithOptions(append) {
+    const parts = append.split("(");
+    const obj = {
+      name: parts[0]
+    };
+    if (parts.length > 1) {
+      const optionsStr = parts[1].replace(")", "");
+      obj.options = import_qs.default.parse(optionsStr);
+      obj.raw = `(${optionsStr})`;
+    }
+    return obj;
+  }
+  parseAppends(appends, filterParams) {
+    if (!appends) return filterParams;
+    appends = import_lodash.default.sortBy(appends, (append) => append.split(".").length);
+    const setInclude = /* @__PURE__ */ __name((model, queryParams, append) => {
+      var _a;
+      const appendWithOptions = this.parseAppendWithOptions(append);
+      append = appendWithOptions.name;
+      const appendFields = append.split(".");
+      const appendAssociation = appendFields[0];
+      const associations = model.associations;
+      let lastLevel = false;
+      if (appendFields.length == 1) {
+        lastLevel = true;
+      }
+      if (appendFields.length == 2) {
+        const association = associations[appendFields[0]];
+        if (!association) {
+          throw new Error(`association ${appendFields[0]} in ${model.name} not found`);
+        }
+        const associationModel = associations[appendFields[0]].target;
+        if (associationModel.rawAttributes[appendFields[1]]) {
+          lastLevel = true;
+        }
+      }
+      if (queryParams["include"] == void 0) {
+        queryParams["include"] = [];
+      }
+      let existIncludeIndex = queryParams["include"].findIndex(
+        (include) => include["association"] == appendAssociation
+      );
+      if (existIncludeIndex != -1) {
+        delete queryParams["include"][existIncludeIndex]["fromFilter"];
+        if (Array.isArray(queryParams["include"][existIncludeIndex]["attributes"]) && queryParams["include"][existIncludeIndex]["attributes"].length == 0) {
+          queryParams["include"][existIncludeIndex]["attributes"] = {
+            include: []
+          };
+        }
+      }
+      if (lastLevel && existIncludeIndex != -1 && ((_a = import_lodash.default.get(queryParams, ["include", existIncludeIndex, "attributes", "include"])) == null ? void 0 : _a.length) == 0) {
+        return;
+      }
+      if (existIncludeIndex == -1) {
+        queryParams["include"].push({
+          association: appendAssociation,
+          options: appendWithOptions.options || {}
+        });
+        existIncludeIndex = queryParams["include"].length - 1;
+      }
+      if (lastLevel) {
+        let attributes = queryParams["include"][existIncludeIndex]["attributes"] || {
+          include: []
+          // all fields are output by default
+        };
+        if (appendFields.length == 2) {
+          if (!Array.isArray(attributes)) {
+            attributes = [];
+          }
+          const attributeName = appendFields[1];
+          attributes.push(attributeName);
+        } else {
+          if (Array.isArray(attributes) && attributes.length == 0) {
+            attributes = {
+              include: []
+            };
+          }
+        }
+        queryParams["include"][existIncludeIndex] = {
+          ...queryParams["include"][existIncludeIndex],
+          attributes
+        };
+      } else {
+        const existInclude = queryParams["include"][existIncludeIndex];
+        if (existInclude.attributes && Array.isArray(existInclude.attributes) && existInclude.attributes.length == 0) {
+          existInclude.attributes = {
+            include: []
+          };
+        }
+        let nextAppend = appendFields.filter((_, index) => index !== 0).join(".");
+        if (appendWithOptions.raw) {
+          nextAppend += appendWithOptions.raw;
+        }
+        setInclude(
+          model.associations[queryParams["include"][existIncludeIndex].association].target,
+          queryParams["include"][existIncludeIndex],
+          nextAppend
+        );
+      }
+    }, "setInclude");
+    for (const append of appends) {
+      setInclude(this.model, filterParams, append);
+    }
+    debug("filter params: %o", filterParams);
+    return filterParams;
+  }
+};
+__name(_OptionsParser, "OptionsParser");
+let OptionsParser = _OptionsParser;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OptionsParser
+});

package/lib/playground.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/playground.js

@@ -0,0 +1,43 @@
+var import_database = require("./database");
+const db = new import_database.Database({
+  dialect: "sqlite",
+  dialectModule: require("sqlite3"),
+  storage: ":memory:"
+});
+(async () => {
+  const User = db.collection({
+    name: "users",
+    fields: [{ type: "string", name: "name" }]
+  });
+  const Post = db.collection({
+    name: "posts",
+    fields: [
+      { type: "string", name: "title" },
+      {
+        type: "belongsTo",
+        name: "user"
+      }
+    ]
+  });
+  await db.sync();
+  const repository = User.repository;
+  await repository.createMany({
+    records: [
+      { name: "u1", posts: [{ title: "u1t1" }] },
+      { name: "u2", posts: [{ title: "u2t1" }] },
+      { name: "u3", posts: [{ title: "u3t1" }] }
+    ]
+  });
+  const Model = User.model;
+  const user = await Model.findOne({
+    subQuery: false,
+    where: {
+      "$posts.title$": "u1t1"
+    },
+    include: { association: "posts", attributes: [] },
+    attributes: {
+      include: []
+    }
+  });
+  console.log(user.toJSON());
+})();

package/lib/query-interface/mysql-query-interface.d.ts

@@ -0,0 +1,35 @@
+import { Transaction, Transactionable } from 'sequelize';
+import { Collection } from '../collection';
+import QueryInterface, { TableInfo } from './query-interface';
+export default class MysqlQueryInterface extends QueryInterface {
+    constructor(db: any);
+    collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+    listViews(): Promise<[unknown[], unknown]>;
+    viewColumnUsage(options: {
+        viewName: string;
+        schema?: string;
+    }): Promise<{
+        [view_column_name: string]: {
+            column_name: string;
+            table_name: string;
+            table_schema?: string;
+        };
+    }>;
+    parseSQL(sql: string): any;
+    viewDef(viewName: string): Promise<string>;
+    showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
+    setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal: number;
+        transaction?: Transaction;
+    }): Promise<void>;
+}

package/lib/query-interface/mysql-query-interface.js

@@ -0,0 +1,122 @@
+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 __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 mysql_query_interface_exports = {};
+__export(mysql_query_interface_exports, {
+  default: () => MysqlQueryInterface
+});
+module.exports = __toCommonJS(mysql_query_interface_exports);
+var import_sql_parser = __toESM(require("../sql-parser"));
+var import_query_interface = __toESM(require("./query-interface"));
+const _MysqlQueryInterface = class _MysqlQueryInterface extends import_query_interface.default {
+  constructor(db) {
+    super(db);
+  }
+  async collectionTableExists(collection, options) {
+    const transaction = options == null ? void 0 : options.transaction;
+    const tableName = collection.model.tableName;
+    const databaseName = this.db.options.database;
+    const sql = `SELECT TABLE_NAME
+                 FROM INFORMATION_SCHEMA.TABLES
+                 WHERE TABLE_SCHEMA = '${databaseName}'
+                   AND TABLE_NAME = '${tableName}'`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT", transaction });
+    return results.length > 0;
+  }
+  async listViews() {
+    const sql = `SELECT TABLE_NAME as name, VIEW_DEFINITION as definition
+                 FROM information_schema.views
+                 WHERE TABLE_SCHEMA = DATABASE()
+                 ORDER BY TABLE_NAME;`;
+    return await this.db.sequelize.query(sql, { type: "SELECT" });
+  }
+  async viewColumnUsage(options) {
+    try {
+      const { ast } = this.parseSQL(await this.viewDef(options.viewName));
+      const columns = ast.columns;
+      const results = [];
+      for (const column of columns) {
+        if (column.expr.type === "column_ref") {
+          results.push([
+            column.as || column.expr.column,
+            {
+              column_name: column.expr.column,
+              table_name: column.expr.table
+            }
+          ]);
+        }
+      }
+      return Object.fromEntries(results);
+    } catch (e) {
+      this.db.logger.warn(e);
+      return {};
+    }
+  }
+  parseSQL(sql) {
+    return import_sql_parser.default.parse(sql);
+  }
+  async viewDef(viewName) {
+    const viewDefinition = await this.db.sequelize.query(`SHOW CREATE VIEW ${viewName}`, { type: "SELECT" });
+    const createView = viewDefinition[0]["Create View"];
+    const regex = /(?<=AS\s)([\s\S]*)/i;
+    const match = createView.match(regex);
+    const sql = match[0];
+    return sql;
+  }
+  async showTableDefinition(tableInfo) {
+    const { tableName } = tableInfo;
+    const sql = `SHOW CREATE TABLE ${tableName}`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT" });
+    return results[0]["Create Table"];
+  }
+  async getAutoIncrementInfo(options) {
+    const { tableInfo, fieldName } = options;
+    const sql = `SELECT AUTO_INCREMENT as currentVal
+                 FROM information_schema.tables
+                 WHERE table_schema = DATABASE()
+                   AND table_name = '${tableInfo.tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT" });
+    let currentVal = results[0]["currentVal"];
+    if (currentVal === null) {
+      const maxSql = `SELECT MAX(${fieldName}) as currentVal
+                      FROM ${tableInfo.tableName};`;
+      const maxResults = await this.db.sequelize.query(maxSql, { type: "SELECT" });
+      currentVal = maxResults[0]["currentVal"];
+    }
+    return {
+      currentVal
+    };
+  }
+  async setAutoIncrementVal(options) {
+    const { tableInfo, columnName, seqName, currentVal, transaction } = options;
+    const sql = `ALTER TABLE ${tableInfo.tableName} AUTO_INCREMENT = ${currentVal};`;
+    await this.db.sequelize.query(sql, { transaction });
+  }
+};
+__name(_MysqlQueryInterface, "MysqlQueryInterface");
+let MysqlQueryInterface = _MysqlQueryInterface;

package/lib/query-interface/postgres-query-interface.d.ts

@@ -0,0 +1,32 @@
+import { Transaction } from 'sequelize';
+import { Collection } from '../collection';
+import QueryInterface, { TableInfo } from './query-interface';
+export default class PostgresQueryInterface extends QueryInterface {
+    constructor(db: any);
+    setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal?: number;
+        transaction?: Transaction;
+    }): Promise<void>;
+    getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
+    collectionTableExists(collection: Collection, options?: any): Promise<any>;
+    listViews(): Promise<[unknown[], unknown]>;
+    viewDef(viewName: string): Promise<string>;
+    parseSQL(sql: string): any;
+    viewColumnUsage(options: any): Promise<{
+        [view_column_name: string]: {
+            column_name: string;
+            table_name: string;
+            table_schema?: string;
+        };
+    }>;
+    showTableDefinition(tableInfo: TableInfo): Promise<any>;
+}