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

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

@@ -0,0 +1,18 @@
+import Database, { Collection, MagicAttributeModel, Transactionable } from '@nocobase/database';
+interface LoadOptions extends Transactionable {
+    skipExist?: boolean;
+}
+export declare class FieldModel extends MagicAttributeModel {
+    get db(): Database;
+    isAssociationField(): boolean;
+    load(loadOptions?: LoadOptions): Promise<import("@nocobase/database").Field>;
+    syncSortByField(options: Transactionable): 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 {};

package/dist/server/models/field.js

@@ -0,0 +1,164 @@
+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 field_exports = {};
+__export(field_exports, {
+  FieldModel: () => FieldModel
+});
+module.exports = __toCommonJS(field_exports);
+var import_database = require("@nocobase/database");
+class FieldModel extends import_database.MagicAttributeModel {
+  get db() {
+    return this.constructor.database;
+  }
+  isAssociationField() {
+    return ["belongsTo", "hasOne", "hasMany", "belongsToMany"].includes(this.get("type"));
+  }
+  async load(loadOptions) {
+    const { skipExist = false, transaction } = loadOptions || {};
+    const collectionName = this.get("collectionName");
+    if (!this.db.hasCollection(collectionName)) {
+      return;
+    }
+    const collection = this.db.getCollection(collectionName);
+    const name = this.get("name");
+    if (skipExist && collection.hasField(name)) {
+      return collection.getField(name);
+    }
+    const options = this.get();
+    const field = await (async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      return collection.setField(name, options);
+    })();
+    await this.db.emitAsync("field:loaded", {
+      fieldKey: this.get("key"),
+      transaction
+    });
+    return field;
+  }
+  async syncSortByField(options) {
+    const collectionName = this.get("collectionName");
+    const collection = this.db.getCollection(collectionName);
+    await this.load(options);
+    await collection.sync({
+      force: false,
+      alter: {
+        drop: false
+      },
+      // @ts-ignore
+      transaction: options.transaction
+    });
+  }
+  async remove(options) {
+    const collection = this.getFieldCollection();
+    if (!collection) {
+      return;
+    }
+    return collection.removeFieldFromDb(this.get("name"), {
+      transaction: options.transaction
+    });
+  }
+  async syncUniqueIndex(options) {
+    const unique = this.get("unique");
+    const collection = this.getFieldCollection();
+    const field = collection.getField(this.get("name"));
+    const columnName = collection.model.rawAttributes[this.get("name")].field;
+    const tableName = collection.model.tableName;
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const existsIndexes = await queryInterface.showIndex(collection.getTableNameWithSchema(), {
+      transaction: options.transaction
+    });
+    const existUniqueIndex = existsIndexes.find((item) => {
+      return item.unique && item.fields[0].attribute === columnName && item.fields.length === 1;
+    });
+    let existsUniqueConstraint;
+    const constraintName = `${tableName}_${field.name}_uk`;
+    if (existUniqueIndex) {
+      const existsUniqueConstraints = await queryInterface.showConstraint(
+        collection.getTableNameWithSchema(),
+        constraintName,
+        {}
+      );
+      existsUniqueConstraint = existsUniqueConstraints[0];
+    }
+    if (unique && !existsUniqueConstraint) {
+      await collection.sync({ ...options, force: false, alter: { drop: false } });
+      await queryInterface.addConstraint(collection.getTableNameWithSchema(), {
+        type: "unique",
+        fields: [columnName],
+        name: constraintName,
+        transaction: options.transaction
+      });
+      this.db.logger.info(`add unique index ${constraintName}`);
+    }
+    if (!unique && existsUniqueConstraint) {
+      await queryInterface.removeConstraint(collection.getTableNameWithSchema(), constraintName, {
+        transaction: options.transaction
+      });
+      this.db.logger.info(`remove unique index ${constraintName}`);
+    }
+  }
+  async syncDefaultValue(options) {
+    const collection = this.getFieldCollection();
+    if (!collection) {
+      return;
+    }
+    if (collection.isView()) {
+      return;
+    }
+    const field = collection.getField(this.get("name"));
+    if (field.get("overriding")) {
+      return;
+    }
+    const queryInterface = collection.db.sequelize.getQueryInterface();
+    await queryInterface.changeColumn(
+      collection.getTableNameWithSchema(),
+      collection.model.rawAttributes[this.get("name")].field,
+      {
+        type: field.dataType,
+        defaultValue: options.defaultValue
+      },
+      {
+        transaction: options.transaction
+      }
+    );
+  }
+  async syncReferenceCheckOption(options) {
+    const reverseKey = this.get("reverseKey");
+    if (!reverseKey)
+      return;
+    const reverseField = await this.db.getCollection("fields").repository.findOne({
+      filterByTk: reverseKey,
+      transaction: options.transaction
+    });
+    if (!reverseField)
+      return;
+    reverseField.set("onDelete", this.get("onDelete"));
+    await reverseField.save({ hooks: false, transaction: options.transaction });
+  }
+  getFieldCollection() {
+    const collectionName = this.get("collectionName");
+    if (!this.db.hasCollection(collectionName)) {
+      return;
+    }
+    return this.db.getCollection(collectionName);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FieldModel
+});

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

@@ -0,0 +1,2 @@
+export * from './collection';
+export * from './field';

package/dist/server/models/index.js

@@ -0,0 +1,23 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var models_exports = {};
+module.exports = __toCommonJS(models_exports);
+__reExport(models_exports, require("./collection"), module.exports);
+__reExport(models_exports, require("./field"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./collection"),
+  ...require("./field")
+});

package/dist/server/repositories/collection-repository.d.ts

@@ -0,0 +1,12 @@
+import { Repository } from '@nocobase/database';
+interface LoadOptions {
+    filter?: any;
+    skipExist?: boolean;
+}
+export declare class CollectionRepository extends Repository {
+    private app;
+    setApp(app: any): void;
+    load(options?: LoadOptions): Promise<void>;
+    db2cm(collectionName: string): Promise<void>;
+}
+export {};

package/dist/server/repositories/collection-repository.js

@@ -0,0 +1,159 @@
+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_repository_exports = {};
+__export(collection_repository_exports, {
+  CollectionRepository: () => CollectionRepository
+});
+module.exports = __toCommonJS(collection_repository_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("@nocobase/utils");
+var import_lodash = __toESM(require("lodash"));
+class CollectionRepository extends import_database.Repository {
+  app;
+  setApp(app) {
+    this.app = app;
+  }
+  async load(options = {}) {
+    const { filter, skipExist } = options;
+    const instances = await this.find({ filter, appends: ["fields"] });
+    const graphlib = import_utils.CollectionsGraph.graphlib();
+    const graph = new graphlib.Graph();
+    const nameMap = {};
+    const viewCollections = [];
+    for (const instance of instances) {
+      graph.setNode(instance.get("name"));
+      if (instance.get("view") || instance.get("sql")) {
+        viewCollections.push(instance.get("name"));
+      }
+    }
+    for (const instance of instances) {
+      const collectionName = instance.get("name");
+      nameMap[collectionName] = instance;
+      if (instance.get("inherits")) {
+        for (const parent of instance.get("inherits")) {
+          graph.setEdge(parent, collectionName);
+        }
+      }
+    }
+    if (graph.nodeCount() === 0)
+      return;
+    if (!graphlib.alg.isAcyclic(graph)) {
+      const cycles = graphlib.alg.findCycles(graph);
+      throw new Error(`Cyclic dependencies: ${cycles.map((cycle) => cycle.join(" -> ")).join(", ")}`);
+    }
+    const sortedNames = graphlib.alg.topsort(graph);
+    const lazyCollectionFields = /* @__PURE__ */ new Map();
+    for (const instanceName of sortedNames) {
+      if (!nameMap[instanceName])
+        continue;
+      const skipField = (() => {
+        if (viewCollections.includes(instanceName)) {
+          return true;
+        }
+        const fields = nameMap[instanceName].get("fields");
+        return fields.filter((field) => field["type"] === "belongsTo" || field["type"] === "belongsToMany").map((field) => field.get("name"));
+      })();
+      if (import_lodash.default.isArray(skipField) && skipField.length) {
+        lazyCollectionFields.set(instanceName, skipField);
+      }
+      this.database.logger.debug(`load collection`, {
+        instanceName,
+        submodule: "CollectionRepository",
+        method: "load"
+      });
+      this.app.setMaintainingMessage(`load ${instanceName} collection`);
+      await nameMap[instanceName].load({ skipField });
+    }
+    const fieldWithSourceAttributes = /* @__PURE__ */ new Map();
+    for (const viewCollectionName of viewCollections) {
+      this.database.logger.debug(`load collection fields`, {
+        submodule: "CollectionRepository",
+        method: "load",
+        viewCollectionName
+      });
+      const skipField = (() => {
+        const fields = nameMap[viewCollectionName].get("fields");
+        return fields.filter((field) => {
+          var _a;
+          if (((_a = field.options) == null ? void 0 : _a.source) && (field["type"] === "belongsTo" || field["type"] === "belongsToMany")) {
+            return true;
+          }
+          return false;
+        }).map((field) => field.get("name"));
+      })();
+      this.app.setMaintainingMessage(`load ${viewCollectionName} collection fields`);
+      if (import_lodash.default.isArray(skipField) && skipField.length) {
+        fieldWithSourceAttributes.set(viewCollectionName, skipField);
+      }
+      await nameMap[viewCollectionName].loadFields({ skipField });
+    }
+    for (const [collectionName, skipField] of lazyCollectionFields) {
+      this.database.logger.debug(`load collection fields`, {
+        submodule: "CollectionRepository",
+        method: "load",
+        collectionName
+      });
+      this.app.setMaintainingMessage(`load ${collectionName} collection fields`);
+      await nameMap[collectionName].loadFields({ includeFields: skipField });
+    }
+    for (const [collectionName, skipField] of fieldWithSourceAttributes) {
+      this.database.logger.debug(`load collection fields`, {
+        submodule: "CollectionRepository",
+        method: "load",
+        collectionName
+      });
+      this.app.setMaintainingMessage(`load ${collectionName} collection fields`);
+      await nameMap[collectionName].loadFields({ includeFields: skipField });
+    }
+  }
+  async db2cm(collectionName) {
+    const collection = this.database.getCollection(collectionName);
+    if (await this.findOne({ filter: { name: collectionName } })) {
+      return;
+    }
+    const options = collection.options;
+    const fields = [];
+    for (const [name, field] of collection.fields) {
+      fields.push({
+        name,
+        ...field.options
+      });
+    }
+    await this.create({
+      values: {
+        ...options,
+        fields,
+        from: "db2cm"
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionRepository
+});

package/dist/server/repositories/index.d.ts

@@ -0,0 +1 @@
+export * from './collection-repository';

package/dist/server/repositories/index.js

@@ -0,0 +1,21 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repositories_exports = {};
+module.exports = __toCommonJS(repositories_exports);
+__reExport(repositories_exports, require("./collection-repository"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./collection-repository")
+});

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

@@ -0,0 +1,4 @@
+declare const _default: {
+    "collections:setFields"(ctx: any, next: any): Promise<void>;
+};
+export default _default;

package/dist/server/resourcers/collections.js

@@ -0,0 +1,93 @@
+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 = {
+  async ["collections:setFields"](ctx, next) {
+    var _a;
+    const { filterByTk, values } = ctx.action.params;
+    const transaction = await ctx.app.db.sequelize.transaction();
+    try {
+      const fields = (_a = values.fields) == null ? void 0 : _a.map((f) => {
+        delete f.key;
+        return f;
+      });
+      const db = ctx.app.db;
+      const collectionModel = await db.getRepository("collections").findOne({
+        filter: {
+          name: filterByTk
+        },
+        transaction
+      });
+      const existFields = await collectionModel.getFields({
+        transaction
+      });
+      const needUpdateFields = fields.filter((f) => {
+        return existFields.find((ef) => ef.name === f.name);
+      }).map((f) => {
+        return {
+          ...f,
+          key: existFields.find((ef) => ef.name === f.name).key
+        };
+      });
+      const needDestroyFields = existFields.filter((ef) => {
+        return !fields.find((f) => f.name === ef.name);
+      });
+      const needCreatedFields = fields.filter((f) => {
+        return !existFields.find((ef) => ef.name === f.name);
+      });
+      if (needDestroyFields.length) {
+        await db.getRepository("fields").destroy({
+          filterByTk: needDestroyFields.map((f) => f.key),
+          transaction
+        });
+      }
+      if (needUpdateFields.length) {
+        await db.getRepository("fields").updateMany({
+          records: needUpdateFields,
+          transaction
+        });
+      }
+      if (needCreatedFields.length) {
+        await db.getRepository("collections.fields", filterByTk).create({
+          values: needCreatedFields,
+          transaction
+        });
+      }
+      await collectionModel.loadFields({
+        transaction
+      });
+      const collection = db.getCollection(filterByTk);
+      await collection.sync({
+        force: false,
+        alter: {
+          drop: false
+        },
+        transaction
+      });
+      await transaction.commit();
+    } catch (e) {
+      await transaction.rollback();
+      throw e;
+    }
+    await next();
+  }
+};

package/dist/server/resourcers/sql.d.ts

@@ -0,0 +1,10 @@
+import { Context, Next } from '@nocobase/actions';
+declare const _default: {
+    name: string;
+    actions: {
+        execute: (ctx: Context, next: Next) => Promise<void>;
+        setFields: (ctx: Context, next: Next) => Promise<void>;
+        update: (ctx: Context, next: Next) => Promise<void>;
+    };
+};
+export default _default;

package/dist/server/resourcers/sql.js

@@ -0,0 +1,106 @@
+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 sql_exports = {};
+__export(sql_exports, {
+  default: () => sql_default
+});
+module.exports = __toCommonJS(sql_exports);
+var import_database = require("@nocobase/database");
+const updateCollection = async (ctx, transaction) => {
+  const { filterByTk, values } = ctx.action.params;
+  const repo = ctx.db.getRepository("collections");
+  const collection = await repo.findOne({
+    filter: {
+      name: filterByTk
+    },
+    transaction
+  });
+  const existFields = await collection.getFields({ transaction });
+  const deletedFields = existFields.filter((field) => {
+    var _a;
+    return !((_a = values.fields) == null ? void 0 : _a.find((f) => f.name === field.name));
+  });
+  for (const field of deletedFields) {
+    await field.destroy({ transaction });
+  }
+  const upRes = await repo.update({
+    filterByTk,
+    values,
+    updateAssociationValues: ["fields"],
+    transaction
+  });
+  return { collection, upRes };
+};
+var sql_default = {
+  name: "sqlCollection",
+  actions: {
+    execute: async (ctx, next) => {
+      let { sql } = ctx.action.params.values || {};
+      if (!sql) {
+        ctx.throw(400, ctx.t("Please enter a SQL statement"));
+      }
+      sql = sql.trim().split(";").shift();
+      if (!/^select/i.test(sql) && !/^with([\s\S]+)select([\s\S]+)/i.test(sql)) {
+        ctx.throw(400, ctx.t("Only supports SELECT statements or WITH clauses"));
+      }
+      const tmpCollection = new import_database.SqlCollection({ name: "tmp", sql }, { database: ctx.db });
+      const model = tmpCollection.model;
+      const data = await model.findAll({ attributes: ["*"], limit: 5, raw: true });
+      let fields = {};
+      try {
+        fields = model.inferFields();
+      } catch (err) {
+        ctx.logger.warn(`resource: sql-collection, action: execute, error: ${err}`);
+        fields = {};
+      }
+      const sources = Array.from(new Set(Object.values(fields).map((field) => field.collection)));
+      ctx.body = { data, fields, sources };
+      await next();
+    },
+    setFields: async (ctx, next) => {
+      const transaction = await ctx.app.db.sequelize.transaction();
+      try {
+        const {
+          upRes: [collection]
+        } = await updateCollection(ctx, transaction);
+        await collection.loadFields({
+          transaction
+        });
+        await transaction.commit();
+      } catch (e) {
+        await transaction.rollback();
+        throw e;
+      }
+      await next();
+    },
+    update: async (ctx, next) => {
+      const transaction = await ctx.app.db.sequelize.transaction();
+      try {
+        const { upRes } = await updateCollection(ctx, transaction);
+        const [collection] = upRes;
+        await collection.load({ transaction, resetFields: true });
+        await transaction.commit();
+        ctx.body = upRes;
+      } catch (e) {
+        await transaction.rollback();
+        throw e;
+      }
+      await next();
+    }
+  }
+};

package/dist/server/resourcers/views.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    name: string;
+    actions: {
+        get(ctx: any, next: any): Promise<void>;
+        list: (ctx: any, next: any) => Promise<void>;
+        query(ctx: any, next: any): Promise<void>;
+    };
+};
+export default _default;