@nocobase/plugin-data-source-main 1.0.0-alpha.1

package/client.d.ts

@@ -0,0 +1,2 @@
+export * from './dist/client';
+export { default } from './dist/client';

package/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client/index.js');

package/dist/client/index.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@nocobase/client';
+declare class PluginDataSourceMainClient extends Plugin {
+    load(): Promise<void>;
+}
+export default PluginDataSourceMainClient;

package/dist/client/index.js

@@ -0,0 +1 @@
+(function(e,n){typeof exports=="object"&&typeof module!="undefined"?n(exports,require("@nocobase/client")):typeof define=="function"&&define.amd?define(["exports","@nocobase/client"],n):(e=typeof globalThis!="undefined"?globalThis:e||self,n(e["@nocobase/plugin-data-source-main"]={},e["@nocobase/client"]))})(this,function(e,n){"use strict";var a=(e,n,o)=>new Promise((u,d)=>{var c=i=>{try{t(o.next(i))}catch(s){d(s)}},l=i=>{try{t(o.throw(i))}catch(s){d(s)}},t=i=>i.done?u(i.value):Promise.resolve(i.value).then(c,l);t((o=o.apply(e,n)).next())});class o extends n.Plugin{load(){return a(this,null,function*(){})}}e.default=o,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/dist/externalVersion.js

@@ -0,0 +1,13 @@
+module.exports = {
+  "@nocobase/client": "1.0.0-alpha.1",
+  "@nocobase/database": "1.0.0-alpha.1",
+  "@nocobase/plugin-error-handler": "1.0.0-alpha.1",
+  "@nocobase/server": "1.0.0-alpha.1",
+  "async-mutex": "0.3.2",
+  "lodash": "4.17.21",
+  "@nocobase/test": "1.0.0-alpha.1",
+  "@nocobase/utils": "1.0.0-alpha.1",
+  "sequelize": "6.35.2",
+  "@nocobase/actions": "1.0.0-alpha.1",
+  "dayjs": "1.11.10"
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './server';
+export { default } from './server';

package/dist/index.js

@@ -0,0 +1,39 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  default: () => import_server.default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./server"), module.exports);
+var import_server = __toESM(require("./server"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./server")
+});

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

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

package/dist/server/collections/collectionCategories.js

@@ -0,0 +1,52 @@
+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 collectionCategories_exports = {};
+__export(collectionCategories_exports, {
+  default: () => collectionCategories_default
+});
+module.exports = __toCommonJS(collectionCategories_exports);
+var collectionCategories_default = {
+  dumpRules: {
+    group: "required"
+  },
+  shared: true,
+  name: "collectionCategories",
+  autoGenId: true,
+  sortable: true,
+  fields: [
+    {
+      type: "string",
+      name: "name",
+      translation: true
+    },
+    {
+      type: "string",
+      name: "color",
+      defaultValue: "default"
+    },
+    {
+      type: "belongsToMany",
+      name: "collections",
+      target: "collections",
+      foreignKey: "categoryId",
+      otherKey: "collectionName",
+      targetKey: "name",
+      through: "collectionCategory"
+    }
+  ]
+};

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

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

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 '@nocobase/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 '@nocobase/database';
+export declare function afterCreateForForeignKeyField(db: Database): (model: any, options: any) => Promise<void>;

package/dist/server/hooks/afterCreateForForeignKeyField.js

@@ -0,0 +1,208 @@
+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";
+    } else if (attribute.type.constructor.name === "UUID") {
+      type = "uuid";
+    }
+    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
+      };
+    }
+    if (type === "uuid") {
+      data["interface"] = "uuid";
+      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) {
+      console.log(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 '@nocobase/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 '@nocobase/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 '@nocobase/database';
+export declare function beforeCreateForChildrenCollection(db: Database): (model: any, { transaction, context }: {
+    transaction: any;
+    context: any;
+}) => Promise<void>;