@tachybase/database 0.23.8

package/lib/sync-runner.d.ts

@@ -0,0 +1,30 @@
+import { Model as SequelizeModel } from 'sequelize';
+import { Model } from './model';
+export declare class SyncRunner {
+    private model;
+    private readonly collection;
+    private readonly database;
+    private tableDescMap;
+    constructor(model: typeof Model);
+    get tableName(): string | {
+        tableName: string;
+        schema: string;
+        delimiter: string;
+    };
+    get sequelize(): import("sequelize").Sequelize;
+    get queryInterface(): import("sequelize").QueryInterface;
+    get rawAttributes(): {
+        [attribute: string]: import("sequelize").ModelAttributeColumnOptions<SequelizeModel<any, any>>;
+    };
+    runSync(options: any): Promise<any>;
+    handlePrimaryKey(columns: any, options: any): Promise<void>;
+    handleDefaultValues(columns: any, options: any): Promise<void>;
+    handleUniqueIndex(options: any): Promise<void>;
+    getColumns(options: any): Promise<import("sequelize").ColumnsDescription>;
+    isParentColumn(columnName: string, options: any): Promise<boolean>;
+    removeUnusedColumns(columns: any, options: any): Promise<void>;
+    findAttributeByColumnName(columnName: string): any;
+    performSync(options: any): Promise<any>;
+    handleZeroColumnModel(options: any): Promise<void>;
+    handleSchema(options: any): Promise<void>;
+}

package/lib/sync-runner.js

@@ -0,0 +1,277 @@
+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 sync_runner_exports = {};
+__export(sync_runner_exports, {
+  SyncRunner: () => SyncRunner
+});
+module.exports = __toCommonJS(sync_runner_exports);
+var import_utils = require("@tachybase/utils");
+var import_sequelize = require("sequelize");
+var import_zero_column_table_error = require("./errors/zero-column-table-error");
+var import_inherited_sync_runner = require("./inherited-sync-runner");
+const _SyncRunner = class _SyncRunner {
+  constructor(model) {
+    this.model = model;
+    this.collection = model.collection;
+    this.database = model.database;
+  }
+  collection;
+  database;
+  tableDescMap = {};
+  get tableName() {
+    return this.model.getTableName();
+  }
+  get sequelize() {
+    return this.model.sequelize;
+  }
+  get queryInterface() {
+    return this.sequelize.getQueryInterface();
+  }
+  get rawAttributes() {
+    return this.model.rawAttributes;
+  }
+  async runSync(options) {
+    var _a;
+    if (this.collection.isView()) {
+      return;
+    }
+    if (this.collection.options.sync === false) {
+      return;
+    }
+    const collectionSyncOptions = (_a = this.database.collectionFactory.collectionTypes.get(
+      // @ts-ignore
+      this.collection.constructor
+    )) == null ? void 0 : _a.onSync;
+    if (collectionSyncOptions) {
+      await collectionSyncOptions(this.model, options);
+      return;
+    }
+    await this.handleSchema(options);
+    try {
+      await this.handleZeroColumnModel(options);
+    } catch (e) {
+      if (e instanceof import_zero_column_table_error.ZeroColumnTableError) {
+        return;
+      }
+      throw e;
+    }
+    const syncResult = await this.performSync(options);
+    const columns = await this.queryInterface.describeTable(this.tableName, options);
+    await this.handlePrimaryKey(columns, options);
+    await this.handleDefaultValues(columns, options);
+    await this.handleUniqueIndex(options);
+    return syncResult;
+  }
+  async handlePrimaryKey(columns, options) {
+    if (!this.database.inDialect("postgres")) {
+      return;
+    }
+    try {
+      const columnsBePrimaryKey = Object.keys(columns).filter((key) => {
+        return columns[key].primaryKey == true;
+      }).sort();
+      const columnsWillBePrimaryKey = Object.keys(this.rawAttributes).filter((key) => {
+        return this.rawAttributes[key].primaryKey == true;
+      }).map((key) => {
+        return this.rawAttributes[key].field;
+      }).sort();
+      if (columnsWillBePrimaryKey.length == 0) {
+        return;
+      }
+      if (JSON.stringify(columnsBePrimaryKey) != JSON.stringify(columnsWillBePrimaryKey)) {
+        await this.queryInterface.addConstraint(this.tableName, {
+          type: "primary key",
+          fields: columnsWillBePrimaryKey,
+          name: `${this.collection.tableName()}_${columnsWillBePrimaryKey.join("_")}_pk`,
+          transaction: options == null ? void 0 : options.transaction
+        });
+      }
+    } catch (e) {
+      if (e.message.includes("No description found")) {
+        return;
+      }
+    }
+  }
+  async handleDefaultValues(columns, options) {
+    const isJSONColumn = /* @__PURE__ */ __name((column) => {
+      return ["JSON", "JSONB"].includes(column.type);
+    }, "isJSONColumn");
+    for (const columnName in columns) {
+      const column = columns[columnName];
+      const isPrimaryKey = /* @__PURE__ */ __name(() => {
+        const attribute = this.findAttributeByColumnName(columnName);
+        return attribute && attribute.primaryKey || column.primaryKey;
+      }, "isPrimaryKey");
+      if (isPrimaryKey()) continue;
+      if (await this.isParentColumn(columnName, options)) continue;
+      const currentAttribute = this.findAttributeByColumnName(columnName);
+      if (!currentAttribute) continue;
+      const attributeDefaultValue = (0, import_utils.isPlainObject)(currentAttribute.defaultValue) && isJSONColumn(column) ? JSON.stringify(currentAttribute.defaultValue) : currentAttribute.defaultValue;
+      const columnDefaultValue = columns[columnName].defaultValue;
+      if (columnDefaultValue === null && attributeDefaultValue === void 0) continue;
+      if (columnDefaultValue === "NULL" && attributeDefaultValue === null) continue;
+      if (columnDefaultValue != attributeDefaultValue) {
+        const changeAttribute = {
+          ...currentAttribute,
+          defaultValue: attributeDefaultValue
+        };
+        if (this.database.inDialect("postgres")) {
+          const query = this.queryInterface.queryGenerator.attributesToSQL(
+            {
+              // @ts-ignore
+              [columnName]: this.queryInterface.normalizeAttribute(changeAttribute)
+            },
+            {
+              context: "changeColumn",
+              table: this.tableName
+            }
+          );
+          const sql = this.queryInterface.queryGenerator.changeColumnQuery(this.tableName, query);
+          const regex = /;ALTER TABLE "[^"]+"(\."[^"]+")? ALTER COLUMN "[^"]+" TYPE [^;]+;?$/;
+          await this.sequelize.query(sql.replace(regex, ""), options);
+        } else {
+          await this.queryInterface.changeColumn(this.tableName, columnName, changeAttribute, options);
+        }
+      }
+    }
+  }
+  async handleUniqueIndex(options) {
+    const existsIndexes = await this.queryInterface.showIndex(this.collection.getTableNameWithSchema(), options);
+    const existsUniqueIndexes = existsIndexes.filter((index) => index.unique);
+    const uniqueAttributes = Object.keys(this.rawAttributes).filter((key) => {
+      return this.rawAttributes[key].unique == true;
+    });
+    for (const existUniqueIndex of existsUniqueIndexes) {
+      const isSingleField = existUniqueIndex.fields.length == 1;
+      if (!isSingleField) continue;
+      const columnName = existUniqueIndex.fields[0].attribute;
+      const currentAttribute = this.findAttributeByColumnName(columnName);
+      if (!currentAttribute || !currentAttribute.unique && !currentAttribute.primaryKey) {
+        if (this.database.inDialect("postgres")) {
+          const constraints = await this.queryInterface.showConstraint(this.tableName, existUniqueIndex.name, options);
+          if (constraints.some((c) => c.constraintName === existUniqueIndex.name)) {
+            await this.queryInterface.removeConstraint(this.tableName, existUniqueIndex.name, options);
+          }
+        }
+        if (this.database.inDialect("sqlite")) {
+          const changeAttribute = {
+            ...currentAttribute,
+            unique: false
+          };
+          await this.queryInterface.changeColumn(this.tableName, columnName, changeAttribute, options);
+        } else {
+          await this.queryInterface.removeIndex(this.tableName, existUniqueIndex.name, options);
+        }
+      }
+    }
+    for (const uniqueAttribute of uniqueAttributes) {
+      const indexExists = existsUniqueIndexes.find((index) => {
+        return index.fields.length == 1 && index.fields[0].attribute == this.rawAttributes[uniqueAttribute].field;
+      });
+      if (!indexExists) {
+        await this.queryInterface.addIndex(this.tableName, [this.rawAttributes[uniqueAttribute].field], {
+          unique: true,
+          transaction: options == null ? void 0 : options.transaction
+        });
+      }
+    }
+  }
+  async getColumns(options) {
+    return await this.queryInterface.describeTable(this.tableName, options);
+  }
+  async isParentColumn(columnName, options) {
+    if (this.collection.isInherited()) {
+      const parentCollections = this.collection.getFlatParents();
+      for (const parentCollection of parentCollections) {
+        let parentColumns = this.tableDescMap[parentCollection.name];
+        if (!parentColumns) {
+          parentColumns = await this.queryInterface.describeTable(parentCollection.getTableNameWithSchema(), options);
+          this.tableDescMap[parentCollection.name] = parentColumns;
+        }
+        if (parentColumns[columnName]) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  async removeUnusedColumns(columns, options) {
+    for (const columnName in columns) {
+      const currentAttribute = this.findAttributeByColumnName(columnName);
+      if (!currentAttribute) {
+        let shouldDelete = true;
+        if (await this.isParentColumn(columnName, options)) {
+          shouldDelete = false;
+        }
+        if (shouldDelete) {
+          await this.queryInterface.removeColumn(this.model.getTableName(), columnName, options);
+          continue;
+        }
+      }
+    }
+  }
+  findAttributeByColumnName(columnName) {
+    return Object.values(this.rawAttributes).find((attribute) => {
+      return attribute.field == columnName;
+    });
+  }
+  async performSync(options) {
+    return this.collection.isInherited() ? await import_inherited_sync_runner.InheritedSyncRunner.syncInheritModel(this.model, options) : await import_sequelize.Model.sync.call(this.model, options);
+  }
+  async handleZeroColumnModel(options) {
+    if (Object.keys(this.model.tableAttributes).length === 0) {
+      if (this.database.inDialect("sqlite", "mysql", "mariadb", "postgres")) {
+        throw new import_zero_column_table_error.ZeroColumnTableError(
+          `Zero-column tables aren't supported in ${this.database.sequelize.getDialect()}`
+        );
+      }
+      const queryInterface = this.queryInterface;
+      if (!queryInterface.patched) {
+        const oldDescribeTable = queryInterface.describeTable;
+        queryInterface.describeTable = async function(...args) {
+          try {
+            return await oldDescribeTable.call(this, ...args);
+          } catch (err) {
+            if (err.message.includes("No description found for")) {
+              return [];
+            } else {
+              throw err;
+            }
+          }
+        };
+        queryInterface.patched = true;
+      }
+    }
+  }
+  async handleSchema(options) {
+    const _schema = this.model._schema;
+    if (_schema && _schema != "public") {
+      await this.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${_schema}";`, {
+        raw: true,
+        transaction: options == null ? void 0 : options.transaction
+      });
+    }
+  }
+};
+__name(_SyncRunner, "SyncRunner");
+let SyncRunner = _SyncRunner;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SyncRunner
+});

package/lib/types.d.ts

@@ -0,0 +1,49 @@
+import type { CreateOptions, DestroyOptions, SaveOptions, SyncOptions, UpdateOptions } from 'sequelize';
+import { HookReturn } from 'sequelize/types/hooks';
+import { ValidationOptions } from 'sequelize/types/instance-validator';
+import { Collection, CollectionOptions } from './collection';
+import type { Model } from './model';
+export type CollectionNameType = string;
+export type ModelSyncEventType = 'beforeSync' | 'afterSync';
+export type ModelValidateEventType = 'beforeValidate' | 'afterValidate';
+export type ModelCreateEventType = 'beforeCreate' | 'afterCreate';
+export type ModelUpdateEventType = 'beforeUpdate' | 'afterUpdate';
+export type ModelSaveEventType = 'beforeSave' | 'afterSave';
+export type ModelDestroyEventType = 'beforeDestroy' | 'afterDestroy';
+export type ModelCreateWithAssociationsEventType = 'afterCreateWithAssociations';
+export type ModelUpdateWithAssociationsEventType = 'afterUpdateWithAssociations';
+export type ModelSaveWithAssociationsEventType = 'afterSaveWithAssociations';
+export type ModelBulkCreateEvnetType = 'beforeBulkCreate' | 'afterBulkCreate';
+export type ModelBulkUpdateEvnetType = 'beforeBulkUpdate' | 'afterBulkUpdate';
+export type ModelBulkDestroyEvnetType = 'beforeBulkDestroy' | 'afterBulkDestroy';
+export type ModelValidateEventTypes = ModelValidateEventType | `${CollectionNameType}.${ModelValidateEventType}`;
+export type ModelCreateEventTypes = ModelCreateEventType | `${CollectionNameType}.${ModelCreateEventType}`;
+export type ModelUpdateEventTypes = ModelUpdateEventType | `${CollectionNameType}.${ModelUpdateEventType}`;
+export type ModelSaveEventTypes = ModelSaveEventType | `${CollectionNameType}.${ModelSaveEventType}`;
+export type ModelDestroyEventTypes = ModelDestroyEventType | `${CollectionNameType}.${ModelDestroyEventType}`;
+export type ModelCreateWithAssociationsEventTypes = ModelCreateWithAssociationsEventType | `${CollectionNameType}.${ModelCreateWithAssociationsEventType}`;
+export type ModelUpdateWithAssociationsEventTypes = ModelUpdateWithAssociationsEventType | `${CollectionNameType}.${ModelUpdateWithAssociationsEventType}`;
+export type ModelSaveWithAssociationsEventTypes = ModelSaveWithAssociationsEventType | `${CollectionNameType}.${ModelSaveWithAssociationsEventType}`;
+export type ModelBulkCreateEvnetTypes = ModelBulkCreateEvnetType | `${CollectionNameType}.${ModelBulkCreateEvnetType}`;
+export type ModelBulkUpdateEvnetTypes = ModelBulkUpdateEvnetType | `${CollectionNameType}.${ModelBulkUpdateEvnetType}`;
+export type ModelBulkDestroyEvnetTypes = ModelBulkDestroyEvnetType | `${CollectionNameType}.${ModelBulkDestroyEvnetType}`;
+export type ModelEventTypes = ModelSyncEventType | ModelValidateEventTypes | ModelCreateEventTypes | ModelUpdateEventTypes | ModelSaveEventTypes | ModelDestroyEventTypes | ModelCreateWithAssociationsEventTypes | ModelUpdateWithAssociationsEventTypes | ModelSaveWithAssociationsEventTypes | ModelBulkCreateEvnetTypes | ModelBulkUpdateEvnetTypes | ModelBulkDestroyEvnetTypes;
+export type DatabaseBeforeDefineCollectionEventType = 'beforeDefineCollection';
+export type DatabaseAfterDefineCollectionEventType = 'afterDefineCollection';
+export type DatabaseBeforeRemoveCollectionEventType = 'beforeRemoveCollection';
+export type DatabaseAfterRemoveCollectionEventType = 'afterRemoveCollection';
+export type DatabaseEventTypes = DatabaseBeforeDefineCollectionEventType | DatabaseAfterDefineCollectionEventType | DatabaseBeforeRemoveCollectionEventType | DatabaseAfterRemoveCollectionEventType;
+export type EventType = ModelEventTypes | DatabaseEventTypes | string;
+export type { HookReturn };
+export type SyncListener = (options?: SyncOptions) => HookReturn;
+export type ValidateListener = (model: Model, options?: ValidationOptions) => HookReturn;
+export type CreateListener = (model: Model, options?: CreateOptions) => HookReturn;
+export type UpdateListener = (model: Model, options?: UpdateOptions) => HookReturn;
+export type SaveListener = (model: Model, options?: SaveOptions) => HookReturn;
+export type DestroyListener = (model: Model, options?: DestroyOptions) => HookReturn;
+export type CreateWithAssociationsListener = (model: Model, options?: CreateOptions) => HookReturn;
+export type UpdateWithAssociationsListener = (model: Model, options?: UpdateOptions) => HookReturn;
+export type SaveWithAssociationsListener = (model: Model, options?: SaveOptions) => HookReturn;
+export type BeforeDefineCollectionListener = (options: CollectionOptions) => void;
+export type AfterDefineCollectionListener = (collection: Collection) => void;
+export type RemoveCollectionListener = (collection: Collection) => void;

package/lib/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/update-associations.d.ts

@@ -0,0 +1,60 @@
+import { Association, BelongsToMany, Hookable, Transactionable } from 'sequelize';
+import { Model } from './model';
+export declare function modelAssociations(instance: Model): {
+    [key: string]: Association<import("sequelize").Model<any, any>, import("sequelize").Model<any, any>>;
+};
+export declare function belongsToManyAssociations(instance: Model): Array<BelongsToMany>;
+export declare function modelAssociationByKey(instance: Model, key: string): Association;
+type UpdateValue = {
+    [key: string]: any;
+};
+interface UpdateOptions extends Transactionable {
+    filter?: any;
+    filterByTk?: number | string;
+    whitelist?: string[];
+    blacklist?: string[];
+    updateAssociationValues?: string[];
+    sanitized?: boolean;
+    sourceModel?: Model;
+}
+interface UpdateAssociationOptions extends Transactionable, Hookable {
+    updateAssociationValues?: string[];
+    sourceModel?: Model;
+    context?: any;
+    associationContext?: any;
+    recursive?: boolean;
+}
+export declare function updateModelByValues(instance: Model, values: UpdateValue, options?: UpdateOptions): Promise<void>;
+export declare function updateThroughTableValue(instance: Model, throughName: string, throughValues: any, source: Model, transaction?: any): Promise<any>;
+/**
+ * update association of instance by values
+ * @param instance
+ * @param values
+ * @param options
+ */
+export declare function updateAssociations(instance: Model, values: any, options?: UpdateAssociationOptions): Promise<void>;
+/**
+ * update model association by key
+ * @param instance
+ * @param key
+ * @param value
+ * @param options
+ */
+export declare function updateAssociation(instance: Model, key: string, value: any, options?: UpdateAssociationOptions): Promise<boolean>;
+/**
+ * update belongsTo and HasOne
+ * @param model
+ * @param key
+ * @param value
+ * @param options
+ */
+export declare function updateSingleAssociation(model: Model, key: string, value: any, options?: UpdateAssociationOptions): Promise<boolean>;
+/**
+ * update multiple association of model by value
+ * @param model
+ * @param key
+ * @param value
+ * @param options
+ */
+export declare function updateMultipleAssociation(model: Model, key: string, value: any, options?: UpdateAssociationOptions): Promise<boolean>;
+export {};