@nocobase/data-source-manager 0.20.0-alpha.1

package/lib/data-source.js

@@ -0,0 +1,124 @@
+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 __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 __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 data_source_exports = {};
+__export(data_source_exports, {
+  DataSource: () => DataSource
+});
+module.exports = __toCommonJS(data_source_exports);
+var import_acl = require("@nocobase/acl");
+var import_resourcer = require("@nocobase/resourcer");
+var import_koa_compose = __toESM(require("koa-compose"));
+var import_resource_manager = require("./resource-manager");
+var import_load_default_actions = require("./load-default-actions");
+var import_events = __toESM(require("events"));
+const _DataSource = class _DataSource extends import_events.default {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.init(options);
+  }
+  collectionManager;
+  resourceManager;
+  acl;
+  get name() {
+    return this.options.name;
+  }
+  static testConnection(options) {
+    return Promise.resolve(true);
+  }
+  init(options = {}) {
+    this.acl = this.createACL();
+    this.resourceManager = this.createResourceManager({
+      prefix: "/api",
+      ...options.resourceManager
+    });
+    this.collectionManager = this.createCollectionManager(options);
+    this.resourceManager.registerActionHandlers((0, import_load_default_actions.loadDefaultActions)(this));
+    if (options.acl !== false) {
+      this.resourceManager.use(this.acl.middleware(), { tag: "acl", after: ["auth"] });
+    }
+  }
+  collectionToResourceMiddleware() {
+    return async (ctx, next) => {
+      const params = (0, import_resourcer.parseRequest)(
+        {
+          path: ctx.request.path,
+          method: ctx.request.method
+        },
+        {
+          prefix: this.resourceManager.options.prefix,
+          accessors: this.resourceManager.options.accessors
+        }
+      );
+      if (!params) {
+        return next();
+      }
+      const resourceName = (0, import_resourcer.getNameByParams)(params);
+      if (this.resourceManager.isDefined(resourceName)) {
+        return next();
+      }
+      if (!this.collectionManager.hasCollection(resourceName)) {
+        return next();
+      }
+      this.resourceManager.define({
+        name: resourceName
+      });
+      return next();
+    };
+  }
+  middleware(middlewares = []) {
+    if (!this["_used"]) {
+      for (const [fn, options] of middlewares) {
+        this.resourceManager.use(fn, options);
+      }
+      this["_used"] = true;
+    }
+    return async (ctx, next) => {
+      ctx.getCurrentRepository = () => {
+        const { resourceName, resourceOf } = ctx.action;
+        return this.collectionManager.getRepository(resourceName, resourceOf);
+      };
+      return (0, import_koa_compose.default)([this.collectionToResourceMiddleware(), this.resourceManager.restApiMiddleware()])(ctx, next);
+    };
+  }
+  createACL() {
+    return new import_acl.ACL();
+  }
+  createResourceManager(options) {
+    return new import_resource_manager.ResourceManager(options);
+  }
+  async load(options = {}) {
+  }
+};
+__name(_DataSource, "DataSource");
+let DataSource = _DataSource;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataSource
+});

package/lib/default-actions/list.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@nocobase/actions';
+export declare function list(ctx: Context, next: any): Promise<void>;

package/lib/default-actions/list.js

@@ -0,0 +1,90 @@
+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 list_exports = {};
+__export(list_exports, {
+  list: () => list
+});
+module.exports = __toCommonJS(list_exports);
+var import_utils = require("@nocobase/utils");
+var import_utils2 = require("./utils");
+function totalPage(total, pageSize) {
+  return Math.ceil(total / pageSize);
+}
+__name(totalPage, "totalPage");
+function findArgs(ctx) {
+  var _a;
+  const resourceName = ctx.action.resourceName;
+  const params = ctx.action.params;
+  if (params.tree) {
+    const [collectionName, associationName] = resourceName.split(".");
+    const collection = ctx.db.getCollection(resourceName);
+    if (collection.options.tree && !(associationName && collectionName === collection.name)) {
+      const foreignKey = ((_a = collection.treeParentField) == null ? void 0 : _a.foreignKey) || "parentId";
+      (0, import_utils.assign)(params, { filter: { [foreignKey]: null } }, { filter: "andMerge" });
+    }
+  }
+  const { tree, fields, filter, appends, except, sort } = params;
+  return { tree, filter, fields, appends, except, sort };
+}
+__name(findArgs, "findArgs");
+async function listWithPagination(ctx) {
+  const { page = 1, pageSize = 50 } = ctx.action.params;
+  const repository = (0, import_utils2.getRepositoryFromParams)(ctx);
+  const options = {
+    context: ctx,
+    ...findArgs(ctx),
+    ...(0, import_utils2.pageArgsToLimitArgs)(parseInt(String(page)), parseInt(String(pageSize)))
+  };
+  Object.keys(options).forEach((key) => {
+    if (options[key] === void 0) {
+      delete options[key];
+    }
+  });
+  const [rows, count] = await repository.findAndCount(options);
+  ctx.body = {
+    count,
+    rows,
+    page: Number(page),
+    pageSize: Number(pageSize),
+    totalPage: totalPage(count, pageSize)
+  };
+}
+__name(listWithPagination, "listWithPagination");
+async function listWithNonPaged(ctx) {
+  const repository = (0, import_utils2.getRepositoryFromParams)(ctx);
+  const rows = await repository.find({ context: ctx, ...findArgs(ctx) });
+  ctx.body = rows;
+}
+__name(listWithNonPaged, "listWithNonPaged");
+async function list(ctx, next) {
+  const { paginate } = ctx.action.params;
+  if (paginate === false || paginate === "false") {
+    await listWithNonPaged(ctx);
+    ctx.paginate = false;
+  } else {
+    await listWithPagination(ctx);
+    ctx.paginate = true;
+  }
+  await next();
+}
+__name(list, "list");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  list
+});

package/lib/default-actions/move.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@nocobase/actions';
+export declare function move(ctx: Context, next: any): Promise<void>;

package/lib/default-actions/move.js

@@ -0,0 +1,54 @@
+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 __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 __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 move_exports = {};
+__export(move_exports, {
+  move: () => move
+});
+module.exports = __toCommonJS(move_exports);
+var import_actions = __toESM(require("@nocobase/actions"));
+var import_utils = require("./utils");
+const databaseMoveAction = import_actions.default.move;
+async function move(ctx, next) {
+  const repository = (0, import_utils.getRepositoryFromParams)(ctx);
+  if (repository.move) {
+    ctx.body = await repository.move(ctx.action.params);
+    await next();
+    return;
+  }
+  if (repository.database) {
+    ctx.databaseRepository = repository;
+    return databaseMoveAction(ctx, next);
+  }
+  throw new Error(`Repository can not handle action move for ${ctx.action.resourceName}`);
+}
+__name(move, "move");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  move
+});

package/lib/default-actions/proxy-to-repository.d.ts

@@ -0,0 +1 @@
+export declare function proxyToRepository(paramKeys: string[] | ((ctx: any) => object), repositoryMethod: string): (ctx: any, next: any) => Promise<void>;

package/lib/default-actions/proxy-to-repository.js

@@ -0,0 +1,54 @@
+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 __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 __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 proxy_to_repository_exports = {};
+__export(proxy_to_repository_exports, {
+  proxyToRepository: () => proxyToRepository
+});
+module.exports = __toCommonJS(proxy_to_repository_exports);
+var import_utils = require("./utils");
+var import_lodash = __toESM(require("lodash"));
+function proxyToRepository(paramKeys, repositoryMethod) {
+  return async function(ctx, next) {
+    const repository = (0, import_utils.getRepositoryFromParams)(ctx);
+    const callObj = typeof paramKeys === "function" ? paramKeys(ctx) : { ...import_lodash.default.pick(ctx.action.params, paramKeys), context: ctx };
+    const dataSource = ctx.dataSource;
+    if (!repository[repositoryMethod]) {
+      throw new Error(
+        `Repository can not handle action ${repositoryMethod} for ${ctx.action.resourceName} in ${dataSource.name}`
+      );
+    }
+    ctx.body = await repository[repositoryMethod](callObj);
+    await next();
+  };
+}
+__name(proxyToRepository, "proxyToRepository");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proxyToRepository
+});

package/lib/default-actions/utils.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '@nocobase/actions';
+import { IRepository } from '@nocobase/data-source-manager';
+export declare function pageArgsToLimitArgs(page: number, pageSize: number): {
+    offset: number;
+    limit: number;
+};
+export declare function getRepositoryFromParams(ctx: Context): IRepository;

package/lib/default-actions/utils.js

@@ -0,0 +1,45 @@
+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 utils_exports = {};
+__export(utils_exports, {
+  getRepositoryFromParams: () => getRepositoryFromParams,
+  pageArgsToLimitArgs: () => pageArgsToLimitArgs
+});
+module.exports = __toCommonJS(utils_exports);
+function pageArgsToLimitArgs(page, pageSize) {
+  return {
+    offset: (page - 1) * pageSize,
+    limit: pageSize
+  };
+}
+__name(pageArgsToLimitArgs, "pageArgsToLimitArgs");
+function getRepositoryFromParams(ctx) {
+  const { resourceName, resourceOf } = ctx.action;
+  const dataSource = ctx.dataSource;
+  if (resourceOf) {
+    return dataSource.collectionManager.getRepository(resourceName, resourceOf);
+  }
+  return dataSource.collectionManager.getRepository(resourceName);
+}
+__name(getRepositoryFromParams, "getRepositoryFromParams");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRepositoryFromParams,
+  pageArgsToLimitArgs
+});

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './collection-manager';
+export * from './data-source';
+export * from './data-source-manager';
+export * from './resource-manager';
+export * from './sequelize-collection-manager';
+export * from './sequelize-data-source';
+export * from './load-default-actions';
+export * from './types';
+export * from './data-source-with-database';

package/lib/index.js

@@ -0,0 +1,37 @@
+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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./collection-manager"), module.exports);
+__reExport(src_exports, require("./data-source"), module.exports);
+__reExport(src_exports, require("./data-source-manager"), module.exports);
+__reExport(src_exports, require("./resource-manager"), module.exports);
+__reExport(src_exports, require("./sequelize-collection-manager"), module.exports);
+__reExport(src_exports, require("./sequelize-data-source"), module.exports);
+__reExport(src_exports, require("./load-default-actions"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./data-source-with-database"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./collection-manager"),
+  ...require("./data-source"),
+  ...require("./data-source-manager"),
+  ...require("./resource-manager"),
+  ...require("./sequelize-collection-manager"),
+  ...require("./sequelize-data-source"),
+  ...require("./load-default-actions"),
+  ...require("./types"),
+  ...require("./data-source-with-database")
+});

package/lib/load-default-actions.d.ts

@@ -0,0 +1,7 @@
+import { list } from './default-actions/list';
+import { move } from './default-actions/move';
+import { DataSource } from './data-source';
+export declare function loadDefaultActions(dataSource: DataSource): {
+    list: typeof list;
+    move: typeof move;
+};

package/lib/load-default-actions.js

@@ -0,0 +1,100 @@
+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 load_default_actions_exports = {};
+__export(load_default_actions_exports, {
+  loadDefaultActions: () => loadDefaultActions
+});
+module.exports = __toCommonJS(load_default_actions_exports);
+var import_list = require("./default-actions/list");
+var import_move = require("./default-actions/move");
+var import_proxy_to_repository = require("./default-actions/proxy-to-repository");
+const actions = {
+  add: {
+    params(ctx) {
+      return ctx.action.params.filterByTk || ctx.action.params.filterByTks || ctx.action.params.values;
+    },
+    method: "add"
+  },
+  create: {
+    params: ["whitelist", "blacklist", "updateAssociationValues", "values"],
+    method: "create"
+  },
+  get: {
+    params: ["filterByTk", "fields", "appends", "except", "filter", "targetCollection"],
+    method: "findOne"
+  },
+  update: {
+    params: [
+      "filterByTk",
+      "values",
+      "whitelist",
+      "blacklist",
+      "filter",
+      "updateAssociationValues",
+      "forceUpdate",
+      "targetCollection"
+    ],
+    method: "update"
+  },
+  destroy: {
+    params: ["filterByTk", "filter"],
+    method: "destroy"
+  },
+  firstOrCreate: {
+    params: ["values", "filterKeys"],
+    method: "firstOrCreate"
+  },
+  updateOrCreate: {
+    params: ["values", "filterKeys"],
+    method: "updateOrCreate"
+  },
+  remove: {
+    params(ctx) {
+      return ctx.action.params.filterByTk || ctx.action.params.filterByTks || ctx.action.params.values;
+    },
+    method: "remove"
+  },
+  set: {
+    params(ctx) {
+      return ctx.action.params.filterByTk || ctx.action.params.filterByTks || ctx.action.params.values;
+    },
+    method: "set"
+  },
+  toggle: {
+    params(ctx) {
+      return ctx.action.params.values;
+    },
+    method: "toggle"
+  }
+};
+function loadDefaultActions(dataSource) {
+  return {
+    ...Object.keys(actions).reduce((carry, key) => {
+      carry[key] = (0, import_proxy_to_repository.proxyToRepository)(actions[key].params, actions[key].method);
+      return carry;
+    }, {}),
+    list: import_list.list,
+    move: import_move.move
+  };
+}
+__name(loadDefaultActions, "loadDefaultActions");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadDefaultActions
+});

package/lib/repository.d.ts

@@ -0,0 +1,10 @@
+import { IModel, IRepository } from './types';
+export declare class Repository implements IRepository {
+    create(options: any): Promise<void>;
+    update(options: any): Promise<void>;
+    find(options?: any): Promise<IModel[]>;
+    findOne(options?: any): Promise<IModel>;
+    destroy(options: any): Promise<void>;
+    count(options?: any): Promise<Number>;
+    findAndCount(options?: any): Promise<[IModel[], Number]>;
+}

package/lib/repository.js

@@ -0,0 +1,61 @@
+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 __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 __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 repository_exports = {};
+__export(repository_exports, {
+  Repository: () => Repository
+});
+module.exports = __toCommonJS(repository_exports);
+var console = __toESM(require("console"));
+const _Repository = class _Repository {
+  async create(options) {
+    console.log("Repository.create....");
+  }
+  async update(options) {
+  }
+  async find(options) {
+    return [];
+  }
+  async findOne(options) {
+    return {};
+  }
+  async destroy(options) {
+  }
+  count(options) {
+    return Promise.resolve(void 0);
+  }
+  findAndCount(options) {
+    return Promise.resolve([[], void 0]);
+  }
+};
+__name(_Repository, "Repository");
+let Repository = _Repository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Repository
+});

package/lib/resource-manager.d.ts

@@ -0,0 +1,3 @@
+import { Resourcer } from '@nocobase/resourcer';
+export declare class ResourceManager extends Resourcer {
+}

package/lib/resource-manager.js

@@ -0,0 +1,32 @@
+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 resource_manager_exports = {};
+__export(resource_manager_exports, {
+  ResourceManager: () => ResourceManager
+});
+module.exports = __toCommonJS(resource_manager_exports);
+var import_resourcer = require("@nocobase/resourcer");
+const _ResourceManager = class _ResourceManager extends import_resourcer.Resourcer {
+};
+__name(_ResourceManager, "ResourceManager");
+let ResourceManager = _ResourceManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceManager
+});