@tachybase/database 0.23.8

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

@@ -0,0 +1,189 @@
+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 postgres_query_interface_exports = {};
+__export(postgres_query_interface_exports, {
+  default: () => PostgresQueryInterface
+});
+module.exports = __toCommonJS(postgres_query_interface_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_postgres = __toESM(require("../sql-parser/postgres"));
+var import_query_interface = __toESM(require("./query-interface"));
+const _PostgresQueryInterface = class _PostgresQueryInterface extends import_query_interface.default {
+  constructor(db) {
+    super(db);
+  }
+  async setAutoIncrementVal(options) {
+    const { tableInfo, columnName, seqName, currentVal, transaction } = options;
+    if (!seqName) {
+      throw new Error("seqName is required to set auto increment val in postgres");
+    }
+    await this.db.sequelize.query(
+      `alter table ${this.db.utils.quoteTable({
+        tableName: tableInfo.tableName,
+        schema: tableInfo.schema
+      })}
+            alter column "${columnName}" set default nextval('${seqName}')`,
+      {
+        transaction
+      }
+    );
+    if (currentVal) {
+      await this.db.sequelize.query(`select setval('${seqName}', ${currentVal})`, {
+        transaction
+      });
+    }
+  }
+  async getAutoIncrementInfo(options) {
+    const fieldName = options.fieldName || "id";
+    const tableInfo = options.tableInfo;
+    const sequenceNameResult = await this.db.sequelize.query(
+      `SELECT column_default
+           FROM information_schema.columns
+           WHERE table_name = '${tableInfo.tableName}'
+             and table_schema = '${tableInfo.schema || "public"}'
+             and "column_name" = '${fieldName}';`
+    );
+    const columnDefault = sequenceNameResult[0][0]["column_default"];
+    const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
+    const match = regex.exec(columnDefault);
+    const sequenceName = match[1];
+    const sequenceCurrentValResult = await this.db.sequelize.query(
+      `select last_value
+           from ${sequenceName}`
+    );
+    const sequenceCurrentVal = parseInt(sequenceCurrentValResult[0][0]["last_value"]);
+    return {
+      seqName: sequenceName,
+      currentVal: sequenceCurrentVal
+    };
+  }
+  async collectionTableExists(collection, options) {
+    const transaction = options == null ? void 0 : options.transaction;
+    const tableName = collection.model.tableName;
+    const schema = collection.collectionSchema() || "public";
+    const sql = `SELECT EXISTS(SELECT 1
+                               FROM information_schema.tables
+                               WHERE table_schema = '${schema}'
+                                 AND table_name = '${tableName}')`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT", transaction });
+    return results[0]["exists"];
+  }
+  async listViews() {
+    const sql = `
+      SELECT viewname as name, definition, schemaname as schema
+      FROM pg_views
+      WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY viewname;
+    `;
+    return await this.db.sequelize.query(sql, { type: "SELECT" });
+  }
+  async viewDef(viewName) {
+    const [schema, name] = viewName.split(".");
+    const viewDefQuery = await this.db.sequelize.query(
+      `
+    select pg_get_viewdef(format('%I.%I', '${schema}', '${name}')::regclass, true) as definition
+    `,
+      { type: "SELECT" }
+    );
+    return import_lodash.default.trim(viewDefQuery[0]["definition"]);
+  }
+  parseSQL(sql) {
+    return import_postgres.default.parse(sql);
+  }
+  async viewColumnUsage(options) {
+    const { viewName, schema = "public" } = options;
+    const sql = `
+      SELECT *
+      FROM information_schema.view_column_usage
+      WHERE view_schema = '${schema}'
+        AND view_name = '${viewName}';
+    `;
+    const columnUsages = await this.db.sequelize.query(sql, { type: "SELECT" });
+    const def = await this.viewDef(`${schema}.${viewName}`);
+    try {
+      const { ast } = this.parseSQL(def);
+      const columns = ast[0].columns;
+      const usages = columns.map((column) => {
+        const fieldAlias = column.as || column.expr.column;
+        const columnUsage = columnUsages.find((columnUsage2) => {
+          let columnExprTable = column.expr.table;
+          const from = ast[0].from;
+          if (columnExprTable === null && column.expr.type === "column_ref") {
+            columnExprTable = from[0].table;
+          } else {
+            const findAs = from.find((from2) => from2.as === columnExprTable);
+            if (findAs) {
+              columnExprTable = findAs.table;
+            }
+          }
+          return columnUsage2.column_name === column.expr.column && columnUsage2.table_name === columnExprTable;
+        });
+        return [
+          fieldAlias,
+          columnUsage ? {
+            ...columnUsage
+          } : null
+        ];
+      }).filter(([, columnUsage]) => columnUsage !== null);
+      return Object.fromEntries(usages);
+    } catch (e) {
+      console.log(e);
+      return {};
+    }
+  }
+  async showTableDefinition(tableInfo) {
+    const showFunc = `
+CREATE OR REPLACE FUNCTION show_create_table(p_schema text, p_table_name text)
+RETURNS text AS
+$BODY$
+SELECT 'CREATE TABLE ' || quote_ident(p_schema) || '.' || quote_ident(p_table_name) || ' (' || E'\\n' || '' ||
+    string_agg(column_list.column_expr, ', ' || E'\\n' || '') ||
+    '' || E'\\n' || ');'
+FROM (
+  SELECT '    ' || quote_ident(column_name) || ' ' || data_type ||
+       coalesce('(' || character_maximum_length || ')', '') ||
+       case when is_nullable = 'YES' then '' else ' NOT NULL' end as column_expr
+  FROM information_schema.columns
+  WHERE table_schema = p_schema AND table_name = p_table_name
+  ORDER BY ordinal_position) column_list;
+$BODY$
+  LANGUAGE SQL STABLE;
+    `;
+    await this.db.sequelize.query(showFunc, { type: "RAW" });
+    const res = await this.db.sequelize.query(
+      `SELECT show_create_table('${tableInfo.schema || "public"}', '${tableInfo.tableName}')`,
+      {
+        type: "SELECT"
+      }
+    );
+    return res[0]["show_create_table"];
+  }
+};
+__name(_PostgresQueryInterface, "PostgresQueryInterface");
+let PostgresQueryInterface = _PostgresQueryInterface;

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

@@ -0,0 +1,2 @@
+import Database from '../database';
+export default function buildQueryInterface(db: Database): any;

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

@@ -0,0 +1,46 @@
+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 query_interface_builder_exports = {};
+__export(query_interface_builder_exports, {
+  default: () => buildQueryInterface
+});
+module.exports = __toCommonJS(query_interface_builder_exports);
+var import_mysql_query_interface = __toESM(require("./mysql-query-interface"));
+var import_postgres_query_interface = __toESM(require("./postgres-query-interface"));
+var import_sqlite_query_interface = __toESM(require("./sqlite-query-interface"));
+function buildQueryInterface(db) {
+  const map = {
+    mysql: import_mysql_query_interface.default,
+    mariadb: import_mysql_query_interface.default,
+    postgres: import_postgres_query_interface.default,
+    sqlite: import_sqlite_query_interface.default
+  };
+  return new map[db.options.dialect](db);
+}
+__name(buildQueryInterface, "buildQueryInterface");

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

@@ -0,0 +1,42 @@
+import { QueryInterface as SequelizeQueryInterface, Transaction, Transactionable } from 'sequelize';
+import { Collection } from '../collection';
+import Database from '../database';
+export type TableInfo = {
+    tableName: string;
+    schema?: string;
+};
+export default abstract class QueryInterface {
+    db: Database;
+    sequelizeQueryInterface: SequelizeQueryInterface;
+    protected constructor(db: Database);
+    abstract collectionTableExists(collection: Collection, options?: Transactionable): Promise<boolean>;
+    abstract listViews(): any;
+    abstract viewDef(viewName: string): Promise<string>;
+    abstract viewColumnUsage(options: {
+        viewName: string;
+        schema?: string;
+    }): Promise<{
+        [view_column_name: string]: {
+            column_name: string;
+            table_name: string;
+            table_schema?: string;
+        };
+    }>;
+    abstract parseSQL(sql: string): any;
+    abstract showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    dropAll(options: any): Promise<void>;
+    abstract getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
+    abstract setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal: number;
+        transaction?: Transaction;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,46 @@
+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_interface_exports = {};
+__export(query_interface_exports, {
+  default: () => QueryInterface
+});
+module.exports = __toCommonJS(query_interface_exports);
+const _QueryInterface = class _QueryInterface {
+  constructor(db) {
+    this.db = db;
+    this.sequelizeQueryInterface = db.sequelize.getQueryInterface();
+  }
+  sequelizeQueryInterface;
+  async dropAll(options) {
+    if (options.drop !== true) return;
+    const views = await this.listViews();
+    for (const view of views) {
+      let removeSql;
+      if (view.schema) {
+        removeSql = `DROP VIEW IF EXISTS "${view.schema}"."${view.name}"`;
+      } else {
+        removeSql = `DROP VIEW IF EXISTS ${view.name}`;
+      }
+      await this.db.sequelize.query(removeSql, { transaction: options.transaction });
+    }
+    await this.db.sequelize.getQueryInterface().dropAllTables(options);
+  }
+};
+__name(_QueryInterface, "QueryInterface");
+let QueryInterface = _QueryInterface;

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

@@ -0,0 +1,35 @@
+import { Transaction } from 'sequelize';
+import { Collection } from '../collection';
+import QueryInterface, { TableInfo } from './query-interface';
+export default class SqliteQueryInterface extends QueryInterface {
+    constructor(db: any);
+    collectionTableExists(collection: Collection, options?: any): 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/sqlite-query-interface.js

@@ -0,0 +1,131 @@
+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 sqlite_query_interface_exports = {};
+__export(sqlite_query_interface_exports, {
+  default: () => SqliteQueryInterface
+});
+module.exports = __toCommonJS(sqlite_query_interface_exports);
+var import_sql_parser = __toESM(require("../sql-parser"));
+var import_query_interface = __toESM(require("./query-interface"));
+const _SqliteQueryInterface = class _SqliteQueryInterface 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 sql = `SELECT name
+                 FROM sqlite_master
+                 WHERE type = 'table'
+                   AND name = '${tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT", transaction });
+    return results.length > 0;
+  }
+  async listViews() {
+    const sql = `
+      SELECT name, sql as definition
+      FROM sqlite_master
+      WHERE type = 'view'
+      ORDER BY 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(
+      `SELECT sql
+       FROM sqlite_master
+       WHERE name = '${viewName}' AND type = 'view'`,
+      {
+        type: "SELECT"
+      }
+    );
+    const createView = viewDefinition[0]["sql"];
+    const regex = /(?<=AS\s)([\s\S]*)/i;
+    const match = createView.match(regex);
+    const sql = match[0];
+    return sql;
+  }
+  showTableDefinition(tableInfo) {
+    return Promise.resolve(void 0);
+  }
+  async getAutoIncrementInfo(options) {
+    const { tableInfo } = options;
+    const tableName = tableInfo.tableName;
+    const sql = `SELECT seq
+                 FROM sqlite_sequence
+                 WHERE name = '${tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT" });
+    const row = results[0];
+    if (!row) {
+      return {
+        currentVal: 0
+      };
+    }
+    return {
+      currentVal: row["seq"]
+    };
+  }
+  async setAutoIncrementVal(options) {
+    const { tableInfo, columnName, seqName, currentVal, transaction } = options;
+    const tableName = tableInfo.tableName;
+    const sql = `UPDATE sqlite_sequence
+                 SET seq = ${currentVal}
+                 WHERE name = '${tableName}';`;
+    await this.db.sequelize.query(sql, { transaction });
+  }
+};
+__name(_SqliteQueryInterface, "SqliteQueryInterface");
+let SqliteQueryInterface = _SqliteQueryInterface;

package/lib/relation-repository/belongs-to-many-repository.d.ts

@@ -0,0 +1,21 @@
+import { Transaction } from 'sequelize';
+import { AggregateOptions, CreateOptions, DestroyOptions, TargetKey } from '../repository';
+import { MultipleRelationRepository } from './multiple-relation-repository';
+import { AssociatedOptions, PrimaryKeyWithThroughValues } from './types';
+type CreateBelongsToManyOptions = CreateOptions;
+export declare class BelongsToManyRepository extends MultipleRelationRepository {
+    aggregate(options: AggregateOptions): Promise<any>;
+    create(options?: CreateBelongsToManyOptions): Promise<any>;
+    destroy(options?: TargetKey | TargetKey[] | DestroyOptions): Promise<boolean>;
+    add(options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions): Promise<void>;
+    set(options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions): Promise<void>;
+    toggle(options: TargetKey | {
+        tk?: TargetKey;
+        transaction?: Transaction;
+    }): Promise<void>;
+    extendFindOptions(findOptions: any): any;
+    throughName(): any;
+    throughModel(): any;
+    protected setTargets(call: 'add' | 'set', options: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions): Promise<void>;
+}
+export {};