@tachybase/module-collection 0.23.8

package/dist/server/migrations/20230623145414-number-step.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230623145414-number-step.js

@@ -0,0 +1,71 @@
+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 __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 number_step_exports = {};
+__export(number_step_exports, {
+  default: () => number_step_default
+});
+module.exports = __toCommonJS(number_step_exports);
+var import_server = require("@tachybase/server");
+var import_lodash = __toESM(require("lodash"));
+class number_step_default extends import_server.Migration {
+  appVersion = "<0.10.0-alpha.3";
+  async up() {
+    const transaction = await this.db.sequelize.transaction();
+    const migrateFieldsSchema = async (collection) => {
+      var _a;
+      this.app.logger.info(`Start to migrate ${collection.name} collection's ui schema`);
+      const fieldRecords = await collection.repository.find({
+        transaction,
+        filter: {
+          type: ["bigInt", "float", "double"]
+        }
+      });
+      this.app.logger.info(`Total ${fieldRecords.length} fields need to be migrated`);
+      for (const fieldRecord of fieldRecords) {
+        const uiSchema = fieldRecord.get("uiSchema");
+        if (((_a = uiSchema == null ? void 0 : uiSchema["x-component-props"]) == null ? void 0 : _a.step) !== "0") {
+          continue;
+        }
+        import_lodash.default.set(uiSchema, "x-component-props.step", "1");
+        fieldRecord.set("uiSchema", uiSchema);
+        await fieldRecord.save({
+          transaction
+        });
+        console.log(`changed: ${fieldRecord.get("collectionName")}.${fieldRecord.get("name")}`);
+      }
+    };
+    try {
+      await migrateFieldsSchema(this.db.getCollection("fields"));
+      await transaction.commit();
+    } catch (error) {
+      await transaction.rollback();
+      this.app.logger.error(error);
+      throw error;
+    }
+  }
+}

package/dist/server/migrations/20230704222935-tableoid.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230704222935-tableoid.js

@@ -0,0 +1,73 @@
+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 __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 tableoid_exports = {};
+__export(tableoid_exports, {
+  default: () => tableoid_default
+});
+module.exports = __toCommonJS(tableoid_exports);
+var import_server = require("@tachybase/server");
+var import_lodash = __toESM(require("lodash"));
+class tableoid_default extends import_server.Migration {
+  appVersion = "<0.10.1-alpha.1";
+  async up() {
+    var _a;
+    if (!this.db.inDialect("postgres")) {
+      return;
+    }
+    const repository = this.db.getRepository("collections");
+    let names = [];
+    const items = await repository.find();
+    for (const item of items) {
+      if (Array.isArray((_a = item.options) == null ? void 0 : _a.inherits) && item.options.inherits.length) {
+        names.push(item.name);
+        names.push(...item.options.inherits);
+      }
+    }
+    names = import_lodash.default.uniq(names);
+    console.log("collection names:", names);
+    for (const name of names) {
+      const fieldRepository = this.db.getRepository("fields");
+      await fieldRepository.firstOrCreate({
+        values: {
+          collectionName: name,
+          name: "__collection",
+          type: "virtual",
+          interface: "tableoid",
+          uiSchema: {
+            type: "string",
+            title: '{{t("Table OID")}}',
+            "x-component": "CollectionSelect",
+            "x-component-props": { isTableOid: true },
+            "x-read-pretty": true
+          }
+        },
+        filterKeys: ["name", "collectionName"]
+      });
+    }
+  }
+}

package/dist/server/migrations/20230918024546-set-collection-schema.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20230918024546-set-collection-schema.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 set_collection_schema_exports = {};
+__export(set_collection_schema_exports, {
+  default: () => set_collection_schema_default
+});
+module.exports = __toCommonJS(set_collection_schema_exports);
+var import_server = require("@tachybase/server");
+class set_collection_schema_default extends import_server.Migration {
+  appVersion = "<0.14.0-alpha.4";
+  async up() {
+    if (!this.db.inDialect("postgres")) {
+      return;
+    }
+    if (this.context.app.name !== "main") {
+      return;
+    }
+    const userCollections = await this.db.getRepository("collections").find({
+      filter: {
+        "options.schema": null,
+        "options.from.$ne": "db2cm"
+      }
+    });
+    for (const collection of userCollections) {
+      await collection.set("schema", process.env.COLLECTION_MANAGER_SCHEMA || this.db.options.schema || "public");
+      await collection.save();
+    }
+    await this.context.app.emitAsync("loadCollections");
+  }
+}

package/dist/server/migrations/20240220153103-install-main-datasource.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20240220153103-install-main-datasource.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 install_main_datasource_exports = {};
+__export(install_main_datasource_exports, {
+  default: () => install_main_datasource_default
+});
+module.exports = __toCommonJS(install_main_datasource_exports);
+var import_server = require("@tachybase/server");
+class install_main_datasource_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.20.0-alpha.1";
+  async up() {
+    const dataSourcesCollection = this.app.db.getCollection("dataSources");
+    await dataSourcesCollection.repository.firstOrCreate({
+      filterKeys: ["key"],
+      values: {
+        key: "main",
+        type: "main",
+        displayName: "Main",
+        fixed: true,
+        options: {}
+      }
+    });
+  }
+}

package/dist/server/models/collection.d.ts

@@ -0,0 +1,23 @@
+import Database, { Collection, MagicAttributeModel, SyncOptions, Transactionable } from '@tachybase/database';
+import { QueryInterfaceDropTableOptions } from 'sequelize';
+interface LoadOptions extends Transactionable {
+    skipField?: boolean | Array<string>;
+    skipExist?: boolean;
+    resetFields?: boolean;
+}
+export declare class CollectionModel extends MagicAttributeModel {
+    get db(): Database;
+    toJSON(): any;
+    load(loadOptions?: LoadOptions): Promise<Collection<any, any>>;
+    loadFields(options?: Transactionable & {
+        skipField?: Array<string>;
+        includeFields?: Array<string>;
+    }): Promise<void>;
+    remove(options?: Transactionable & QueryInterfaceDropTableOptions): Promise<void>;
+    migrate(options?: SyncOptions & Transactionable): Promise<void>;
+    isInheritedModel(): any;
+    findParents(options: Transactionable): Promise<any[]>;
+    parentFields(options: Transactionable): Promise<any>;
+    syncParentFields(options: Transactionable): Promise<void>;
+}
+export {};

package/dist/server/models/collection.js

@@ -0,0 +1,221 @@
+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 __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 collection_exports = {};
+__export(collection_exports, {
+  CollectionModel: () => CollectionModel
+});
+module.exports = __toCommonJS(collection_exports);
+var import_database = require("@tachybase/database");
+var import_lodash = __toESM(require("lodash"));
+class CollectionModel extends import_database.MagicAttributeModel {
+  get db() {
+    return this.constructor.database;
+  }
+  toJSON() {
+    const json = super.toJSON();
+    if (!json.filterTargetKey) {
+      const collection = this.db.getCollection(json.name);
+      json.filterTargetKey = collection == null ? void 0 : collection.filterTargetKey;
+    }
+    return json;
+  }
+  async load(loadOptions = {}) {
+    const { skipExist, skipField, resetFields, transaction } = loadOptions;
+    const name = this.get("name");
+    let collection;
+    const collectionOptions = {
+      origin: "@tachybase/module-collection",
+      ...this.get(),
+      fields: [],
+      loadedFromCollectionManager: true
+    };
+    if (!this.db.inDialect("postgres") && collectionOptions.schema) {
+      delete collectionOptions.schema;
+    }
+    if (this.db.hasCollection(name)) {
+      collection = this.db.getCollection(name);
+      if (skipExist) {
+        return collection;
+      }
+      if (resetFields) {
+        collection.resetFields();
+      }
+      collection.updateOptions(collectionOptions);
+    } else {
+      if (!collectionOptions.dumpRules) {
+        import_lodash.default.set(collectionOptions, "dumpRules.group", "custom");
+      }
+      collection = this.db.collection(collectionOptions);
+    }
+    if (!skipField) {
+      await this.loadFields({ transaction });
+    }
+    if (import_lodash.default.isArray(skipField)) {
+      await this.loadFields({ transaction, skipField });
+    }
+    await this.db.emitAsync("collection:loaded", {
+      collection,
+      transaction
+    });
+    return collection;
+  }
+  async loadFields(options = {}) {
+    let fields = this.get("fields") || [];
+    if (!fields.length) {
+      fields = await this.getFields(options);
+    }
+    if (options.skipField) {
+      fields = fields.filter((field) => !options.skipField.includes(field.name));
+    }
+    if (options.includeFields) {
+      fields = fields.filter((field) => options.includeFields.includes(field.name));
+    }
+    if (this.options.view && fields.find((f) => f.name === "id")) {
+      fields = fields.map((field) => {
+        if (field.name === "id") {
+          field.set("primaryKey", true);
+        } else {
+          field.set("primaryKey", false);
+        }
+        return field;
+      });
+    }
+    const instances = fields;
+    for (const instance of instances) {
+      await instance.load(options);
+    }
+  }
+  async remove(options) {
+    const { transaction } = options || {};
+    const name = this.get("name");
+    const collection = this.db.getCollection(name);
+    if (!collection) {
+      return;
+    }
+    const fields = await this.db.getRepository("fields").find({
+      filter: {
+        "type.$in": ["belongsToMany", "belongsTo", "hasMany", "hasOne"]
+      },
+      transaction
+    });
+    for (const field of fields) {
+      if (field.get("target") && field.get("target") === name) {
+        await field.destroy({ transaction });
+      } else if (field.get("through") && field.get("through") === name) {
+        await field.destroy({ transaction });
+      }
+    }
+    await collection.removeFromDb(options);
+  }
+  async migrate(options) {
+    const pendingFieldsTargetToThis = this.db.pendingFields.get(this.get("name")) || [];
+    const getPendingField = () => pendingFieldsTargetToThis.map((field) => {
+      return {
+        name: field.get("name"),
+        collectionName: field.get("collectionName")
+      };
+    });
+    const beforePendingFields = getPendingField();
+    const collection = await this.load({
+      transaction: options == null ? void 0 : options.transaction
+    });
+    const afterPendingFields = getPendingField();
+    const resolvedPendingFields = import_lodash.default.differenceWith(beforePendingFields, afterPendingFields, import_lodash.default.isEqual);
+    const resolvedPendingFieldsCollections = import_lodash.default.uniq(resolvedPendingFields.map((field) => field.collectionName));
+    if (Object.keys(collection.model.tableAttributes).length === 0 && !this.db.inDialect("postgres")) {
+      return;
+    }
+    try {
+      const syncOptions = {
+        force: false,
+        alter: {
+          drop: false
+        },
+        ...options
+      };
+      await collection.sync(syncOptions);
+      for (const collectionName of resolvedPendingFieldsCollections) {
+        await this.db.getCollection(collectionName).sync(syncOptions);
+      }
+    } catch (error) {
+      console.error(error);
+      const name = this.get("name");
+      this.db.removeCollection(name);
+      throw error;
+    }
+  }
+  isInheritedModel() {
+    return this.get("inherits");
+  }
+  async findParents(options) {
+    const { transaction } = options;
+    const findModelParents = async (model, carry = []) => {
+      if (!model.get("inherits")) {
+        return;
+      }
+      const parents = import_lodash.default.castArray(model.get("inherits"));
+      for (const parent of parents) {
+        const parentModel = await this.db.getCollection("collections").repository.findOne({
+          filterByTk: parent,
+          transaction
+        });
+        carry.push(parentModel.get("name"));
+        await findModelParents(parentModel, carry);
+      }
+      return carry;
+    };
+    return findModelParents(this);
+  }
+  async parentFields(options) {
+    const { transaction } = options;
+    return this.db.getCollection("fields").repository.find({
+      filter: {
+        collectionName: { $in: await this.findParents({ transaction }) }
+      },
+      transaction
+    });
+  }
+  // sync fields from parents
+  async syncParentFields(options) {
+    const { transaction } = options;
+    const ancestorFields = await this.parentFields({ transaction });
+    const selfFields = await this.getFields({ transaction });
+    const inheritedFields = ancestorFields.filter((field) => {
+      return !field.isAssociationField() && !selfFields.find((selfField) => selfField.get("name") === field.get("name"));
+    });
+    for (const inheritedField of inheritedFields) {
+      await this.createField(import_lodash.default.omit(inheritedField.toJSON(), ["key", "collectionName", "sort"]), {
+        transaction
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionModel
+});

package/dist/server/models/field.d.ts

@@ -0,0 +1,22 @@
+import Database, { Collection, MagicAttributeModel, SyncOptions, Transactionable } from '@tachybase/database';
+interface LoadOptions extends Transactionable {
+    skipExist?: boolean;
+}
+interface MigrateOptions extends SyncOptions, Transactionable {
+    isNew?: boolean;
+}
+export declare class FieldModel extends MagicAttributeModel {
+    get db(): Database;
+    isAssociationField(): boolean;
+    load(loadOptions?: LoadOptions): Promise<import("@tachybase/database").Field>;
+    syncSortByField(options: Transactionable): Promise<void>;
+    migrate({ isNew, ...options }?: MigrateOptions): Promise<void>;
+    remove(options?: any): Promise<void>;
+    syncUniqueIndex(options: Transactionable): Promise<void>;
+    syncDefaultValue(options: Transactionable & {
+        defaultValue: any;
+    }): Promise<void>;
+    syncReferenceCheckOption(options: Transactionable): Promise<void>;
+    protected getFieldCollection(): Collection | null;
+}
+export {};