@tachybase/module-collection 0.23.8

package/dist/server/collections/collections.js

@@ -0,0 +1,92 @@
+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 collections_exports = {};
+__export(collections_exports, {
+  default: () => collections_default
+});
+module.exports = __toCommonJS(collections_exports);
+var collections_default = {
+  dumpRules: "required",
+  shared: true,
+  name: "collections",
+  sortable: "sort",
+  autoGenId: false,
+  model: "CollectionModel",
+  repository: "CollectionRepository",
+  timestamps: false,
+  filterTargetKey: "name",
+  fields: [
+    {
+      type: "uid",
+      name: "key",
+      primaryKey: true
+    },
+    {
+      type: "uid",
+      name: "name",
+      unique: true,
+      prefix: "t_"
+    },
+    {
+      type: "string",
+      name: "title",
+      required: true,
+      translation: true
+    },
+    {
+      type: "boolean",
+      name: "inherit",
+      defaultValue: false
+    },
+    {
+      type: "boolean",
+      name: "hidden",
+      defaultValue: false
+    },
+    {
+      type: "json",
+      name: "options",
+      defaultValue: {}
+    },
+    {
+      type: "string",
+      name: "description",
+      allowNull: true
+    },
+    {
+      type: "hasMany",
+      name: "fields",
+      target: "fields",
+      sourceKey: "name",
+      targetKey: "name",
+      foreignKey: "collectionName",
+      sortBy: "sort"
+    },
+    {
+      type: "belongsToMany",
+      name: "category",
+      target: "collectionCategories",
+      sourceKey: "name",
+      foreignKey: "collectionName",
+      otherKey: "categoryId",
+      targetKey: "id",
+      sortBy: "sort",
+      through: "collectionCategory"
+    }
+  ]
+};

package/dist/server/collections/fields.d.ts

@@ -0,0 +1,3 @@
+import { CollectionOptions } from '@tachybase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/dist/server/collections/fields.js

@@ -0,0 +1,94 @@
+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 fields_exports = {};
+__export(fields_exports, {
+  default: () => fields_default
+});
+module.exports = __toCommonJS(fields_exports);
+var fields_default = {
+  dumpRules: "required",
+  shared: true,
+  name: "fields",
+  autoGenId: false,
+  model: "FieldModel",
+  timestamps: false,
+  sortable: {
+    name: "sort",
+    scopeKey: "collectionName"
+  },
+  indexes: [
+    {
+      type: "UNIQUE",
+      fields: ["collectionName", "name"]
+    }
+  ],
+  fields: [
+    {
+      type: "uid",
+      name: "key",
+      primaryKey: true
+    },
+    {
+      type: "uid",
+      name: "name",
+      prefix: "f_"
+    },
+    {
+      type: "string",
+      name: "type"
+    },
+    {
+      type: "string",
+      name: "interface",
+      allowNull: true
+    },
+    {
+      type: "string",
+      name: "description",
+      allowNull: true
+    },
+    {
+      type: "belongsTo",
+      name: "collection",
+      target: "collections",
+      foreignKey: "collectionName",
+      targetKey: "name",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "hasMany",
+      name: "children",
+      target: "fields",
+      sourceKey: "key",
+      foreignKey: "parentKey"
+    },
+    {
+      type: "hasOne",
+      name: "reverseField",
+      target: "fields",
+      sourceKey: "key",
+      foreignKey: "reverseKey"
+    },
+    {
+      type: "json",
+      name: "options",
+      defaultValue: {},
+      translation: true
+    }
+  ]
+};

package/dist/server/hooks/afterCreateForForeignKeyField.d.ts

@@ -0,0 +1,2 @@
+import Database from '@tachybase/database';
+export declare function afterCreateForForeignKeyField(db: Database): (model: any, options: any) => Promise<void>;

package/dist/server/hooks/afterCreateForForeignKeyField.js

@@ -0,0 +1,195 @@
+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 afterCreateForForeignKeyField_exports = {};
+__export(afterCreateForForeignKeyField_exports, {
+  afterCreateForForeignKeyField: () => afterCreateForForeignKeyField
+});
+module.exports = __toCommonJS(afterCreateForForeignKeyField_exports);
+function afterCreateForForeignKeyField(db) {
+  function generateFkOptions(collectionName, foreignKey) {
+    const collection = db.getCollection(collectionName);
+    if (!collection) {
+      throw new Error("collection not found");
+    }
+    const M = collection.model;
+    const attr = M.rawAttributes[foreignKey];
+    if (!attr) {
+      throw new Error(`${collectionName}.${foreignKey} does not exists`);
+    }
+    return attribute2field(attr);
+  }
+  function attribute2field(attribute) {
+    let type = "bigInt";
+    if (attribute.type.constructor.name === "INTEGER") {
+      type = "integer";
+    } else if (attribute.type.constructor.name === "STRING") {
+      type = "string";
+    }
+    const name = attribute.fieldName;
+    const data = {
+      interface: "integer",
+      name,
+      type,
+      uiSchema: {
+        type: "number",
+        title: name,
+        "x-component": "InputNumber",
+        "x-read-pretty": true
+      }
+    };
+    if (type === "string") {
+      data["interface"] = "input";
+      data["uiSchema"] = {
+        type: "string",
+        title: name,
+        "x-component": "Input",
+        "x-read-pretty": true
+      };
+    }
+    return data;
+  }
+  async function createFieldIfNotExists({ values, transaction }) {
+    const { collectionName, name } = values;
+    if (!collectionName || !name) {
+      throw new Error(`field options invalid`);
+    }
+    const r = db.getRepository("fields");
+    const instance = await r.findOne({
+      filter: {
+        collectionName,
+        name
+      },
+      transaction
+    });
+    if (instance) {
+      if (instance.type !== values.type) {
+        throw new Error(`fk type invalid`);
+      }
+      instance.set("sort", 1);
+      instance.set("isForeignKey", true);
+      await instance.save({ transaction });
+    } else {
+      const creatInstance = await r.create({
+        values: {
+          isForeignKey: true,
+          ...values
+        },
+        transaction
+      });
+      creatInstance.set("sort", 1);
+      await creatInstance.save({ transaction });
+    }
+    await r.update({
+      filter: {
+        collectionName,
+        options: {
+          primaryKey: true
+        }
+      },
+      values: {
+        sort: 0
+      },
+      transaction
+    });
+  }
+  const hook = async (model, { transaction, context }) => {
+    if (!context) {
+      return;
+    }
+    const {
+      type,
+      interface: interfaceType,
+      collectionName,
+      target,
+      through,
+      foreignKey,
+      otherKey,
+      source
+    } = model.get();
+    if (source) return;
+    if (["oho", "o2m"].includes(interfaceType)) {
+      const values = generateFkOptions(target, foreignKey);
+      await createFieldIfNotExists({
+        values: {
+          collectionName: target,
+          ...values
+        },
+        transaction
+      });
+    } else if (["obo", "m2o"].includes(interfaceType)) {
+      const values = generateFkOptions(collectionName, foreignKey);
+      await createFieldIfNotExists({
+        values: { collectionName, ...values },
+        transaction
+      });
+    } else if (["linkTo", "m2m"].includes(interfaceType)) {
+      if (type !== "belongsToMany") {
+        return;
+      }
+      const r = db.getRepository("collections");
+      const instance = await r.findOne({
+        filter: {
+          name: through
+        },
+        transaction
+      });
+      if (!instance) {
+        await r.create({
+          values: {
+            name: through,
+            title: through,
+            timestamps: true,
+            autoGenId: false,
+            hidden: true,
+            autoCreate: true,
+            isThrough: true,
+            sortable: false
+          },
+          context,
+          transaction
+        });
+      }
+      const opts1 = generateFkOptions(through, foreignKey);
+      const opts2 = generateFkOptions(through, otherKey);
+      await createFieldIfNotExists({
+        values: {
+          collectionName: through,
+          ...opts1
+        },
+        transaction
+      });
+      await createFieldIfNotExists({
+        values: {
+          collectionName: through,
+          ...opts2
+        },
+        transaction
+      });
+    }
+  };
+  return async (model, options) => {
+    try {
+      await hook(model, options);
+    } catch (error) {
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterCreateForForeignKeyField
+});

package/dist/server/hooks/afterCreateForReverseField.d.ts

@@ -0,0 +1,4 @@
+import Database from '@tachybase/database';
+export declare function afterCreateForReverseField(db: Database): (model: any, { transaction }: {
+    transaction: any;
+}) => Promise<void>;

package/dist/server/hooks/afterCreateForReverseField.js

@@ -0,0 +1,37 @@
+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 afterCreateForReverseField_exports = {};
+__export(afterCreateForReverseField_exports, {
+  afterCreateForReverseField: () => afterCreateForReverseField
+});
+module.exports = __toCommonJS(afterCreateForReverseField_exports);
+function afterCreateForReverseField(db) {
+  return async (model, { transaction }) => {
+    const Field = db.getCollection("fields");
+    const reverseKey = model.get("reverseKey");
+    if (!reverseKey) {
+      return;
+    }
+    const reverse = await Field.model.findByPk(reverseKey, { transaction });
+    await reverse.update({ reverseKey: model.get("key") }, { hooks: false, transaction });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterCreateForReverseField
+});

package/dist/server/hooks/afterDestroyForForeignKeyField.d.ts

@@ -0,0 +1,2 @@
+import Database from '@tachybase/database';
+export declare function afterDestroyForForeignKeyField(db: Database): (model: any, opts: any) => Promise<void>;

package/dist/server/hooks/afterDestroyForForeignKeyField.js

@@ -0,0 +1,89 @@
+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 afterDestroyForForeignKeyField_exports = {};
+__export(afterDestroyForForeignKeyField_exports, {
+  afterDestroyForForeignKeyField: () => afterDestroyForForeignKeyField
+});
+module.exports = __toCommonJS(afterDestroyForForeignKeyField_exports);
+async function destroyFields(db, transaction, fieldRecords) {
+  const fieldsRepo = db.getRepository("fields");
+  for (const fieldRecord of fieldRecords) {
+    await fieldsRepo.destroy({
+      filter: {
+        name: fieldRecord.get("name"),
+        collectionName: fieldRecord.get("collectionName")
+      },
+      transaction
+    });
+  }
+}
+function afterDestroyForForeignKeyField(db) {
+  return async (model, opts) => {
+    const { transaction } = opts;
+    const options = model.get("options");
+    if (!(options == null ? void 0 : options.isForeignKey)) {
+      return;
+    }
+    const collectionRepo = db.getRepository("collections");
+    const foreignKey = model.get("name");
+    const foreignKeyCollectionName = model.get("collectionName");
+    const collectionRecord = await collectionRepo.findOne({
+      filter: {
+        name: foreignKeyCollectionName
+      },
+      transaction
+    });
+    const collectionOptions = collectionRecord.get("options");
+    const fieldsRepo = db.getRepository("fields");
+    if (collectionOptions == null ? void 0 : collectionOptions.isThrough) {
+      const fieldRecords = await fieldsRepo.find({
+        filter: {
+          options: { through: foreignKeyCollectionName, foreignKey }
+        },
+        transaction
+      });
+      await destroyFields(db, transaction, fieldRecords);
+    } else {
+      await destroyFields(
+        db,
+        transaction,
+        await fieldsRepo.find({
+          filter: {
+            collectionName: foreignKeyCollectionName,
+            options: { foreignKey }
+          },
+          transaction
+        })
+      );
+      await destroyFields(
+        db,
+        transaction,
+        await fieldsRepo.find({
+          filter: {
+            options: { foreignKey, target: foreignKeyCollectionName }
+          },
+          transaction
+        })
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  afterDestroyForForeignKeyField
+});

package/dist/server/hooks/beforeCreateForChildrenCollection.d.ts

@@ -0,0 +1,5 @@
+import Database from '@tachybase/database';
+export declare function beforeCreateForChildrenCollection(db: Database): (model: any, { transaction, context }: {
+    transaction: any;
+    context: any;
+}) => Promise<void>;

package/dist/server/hooks/beforeCreateForChildrenCollection.js

@@ -0,0 +1,58 @@
+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 beforeCreateForChildrenCollection_exports = {};
+__export(beforeCreateForChildrenCollection_exports, {
+  beforeCreateForChildrenCollection: () => beforeCreateForChildrenCollection
+});
+module.exports = __toCommonJS(beforeCreateForChildrenCollection_exports);
+function beforeCreateForChildrenCollection(db) {
+  return async (model, { transaction, context }) => {
+    const Collection = db.getCollection("collections");
+    const Field = db.getCollection("fields");
+    const parentKey = model.get("parentKey");
+    if (!parentKey) {
+      return;
+    }
+    const parent = await Field.model.findByPk(parentKey, { transaction });
+    const parentTarget = parent.get("target");
+    model.set("collectionName", parentTarget);
+    const collection = await Collection.model.findOne({
+      transaction,
+      where: {
+        name: parentTarget
+      }
+    });
+    if (!collection) {
+      await Collection.repository.create({
+        values: {
+          name: parentTarget,
+          createdBy: true,
+          updatedBy: true,
+          sortable: true,
+          inherit: true
+        },
+        transaction,
+        context
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForChildrenCollection
+});

package/dist/server/hooks/beforeCreateForReverseField.d.ts

@@ -0,0 +1,4 @@
+import Database from '@tachybase/database';
+export declare function beforeCreateForReverseField(db: Database): (model: any, { transaction }: {
+    transaction: any;
+}) => Promise<void>;

package/dist/server/hooks/beforeCreateForReverseField.js

@@ -0,0 +1,64 @@
+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 beforeCreateForReverseField_exports = {};
+__export(beforeCreateForReverseField_exports, {
+  beforeCreateForReverseField: () => beforeCreateForReverseField
+});
+module.exports = __toCommonJS(beforeCreateForReverseField_exports);
+function beforeCreateForReverseField(db) {
+  return async (model, { transaction }) => {
+    const Field = db.getCollection("fields");
+    const reverseKey = model.get("reverseKey");
+    if (!reverseKey) {
+      return;
+    }
+    const reverse = await Field.model.findByPk(reverseKey, { transaction });
+    model.set("collectionName", reverse.get("target"));
+    model.set("target", reverse.get("collectionName"));
+    if (reverse.get("onDelete")) {
+      model.set("onDelete", reverse.get("onDelete"));
+    }
+    const reverseType = reverse.get("type");
+    if (["hasMany", "hasOne"].includes(reverseType)) {
+      model.set("type", "belongsTo");
+      model.set("targetKey", reverse.get("sourceKey"));
+      model.set("foreignKey", reverse.get("foreignKey"));
+      model.set("sourceKey", reverse.get("targetKey"));
+    }
+    if (["belongsTo"].includes(reverseType)) {
+      if (!model.get("type")) {
+        model.set("type", "hasMany");
+      }
+      model.set("sourceKey", reverse.get("targetKey"));
+      model.set("foreignKey", reverse.get("foreignKey"));
+      model.set("targetKey", reverse.get("sourceKey"));
+    }
+    if (["belongsToMany"].includes(reverseType)) {
+      model.set("type", "belongsToMany");
+      model.set("through", reverse.get("through"));
+      model.set("sourceKey", reverse.get("targetKey"));
+      model.set("foreignKey", reverse.get("otherKey"));
+      model.set("targetKey", reverse.get("sourceKey"));
+      model.set("otherKey", reverse.get("foreignKey"));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeCreateForReverseField
+});

package/dist/server/hooks/beforeCreateForValidateField.d.ts

@@ -0,0 +1,4 @@
+import { Database } from '@tachybase/database';
+export declare function beforeCreateForValidateField(db: Database): (model: any, { transaction }: {
+    transaction: any;
+}) => Promise<void>;