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

package/dist/server/resourcers/data-sources-resources.js

@@ -0,0 +1,88 @@
+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 data_sources_resources_exports = {};
+__export(data_sources_resources_exports, {
+  default: () => data_sources_resources_default
+});
+module.exports = __toCommonJS(data_sources_resources_exports);
+var data_sources_resources_default = {
+  name: "roles.dataSourceResources",
+  actions: {
+    async create(ctx, next) {
+      const { associatedIndex: roleName } = ctx.action.params;
+      const db = ctx.db;
+      const transaction = await db.sequelize.transaction();
+      const dataSourceKey = ctx.action.params.values.dataSourceKey;
+      if (!dataSourceKey) {
+        throw new Error("dataSourceKey is required");
+      }
+      const connectionRole = await db.getRepository("dataSourcesRoles").findOne({
+        filter: {
+          roleName,
+          dataSourceKey
+        },
+        transaction
+      });
+      if (!connectionRole) {
+        await db.getRepository("dataSourcesRoles").create({
+          values: {
+            roleName,
+            dataSourceKey
+          },
+          transaction
+        });
+      }
+      const record = await db.getRepository("dataSourcesRolesResources").create({
+        values: {
+          roleName,
+          ...ctx.action.params.values
+        },
+        transaction
+      });
+      await transaction.commit();
+      ctx.body = record.toJSON();
+      await next();
+    },
+    async update(ctx, next) {
+      const { associatedIndex: roleName } = ctx.action.params;
+      ctx.body = await ctx.db.getRepository("dataSourcesRolesResources").update({
+        filter: {
+          roleName,
+          dataSourceKey: ctx.action.params.filter.dataSourceKey,
+          name: ctx.action.params.filter.name
+        },
+        values: ctx.action.params.values,
+        updateAssociationValues: ["actions"]
+      });
+      await next();
+    },
+    async get(ctx, next) {
+      const { associatedIndex: roleName } = ctx.action.params;
+      const record = await ctx.db.getRepository("dataSourcesRolesResources").findOne({
+        filter: {
+          roleName,
+          dataSourceKey: ctx.action.params.filter.dataSourceKey,
+          name: ctx.action.params.filter.name
+        },
+        appends: ctx.action.params.appends
+      });
+      ctx.body = record;
+      await next();
+    }
+  }
+};

package/dist/server/resourcers/data-sources-roles.d.ts

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

package/dist/server/resourcers/data-sources-roles.js

@@ -0,0 +1,72 @@
+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 data_sources_roles_exports = {};
+__export(data_sources_roles_exports, {
+  default: () => data_sources_roles_default
+});
+module.exports = __toCommonJS(data_sources_roles_exports);
+var data_sources_roles_default = {
+  name: "dataSources.roles",
+  actions: {
+    async update(ctx, next) {
+      const params = ctx.action.params;
+      const { filterByTk: name, associatedIndex: dataSourceKey } = params;
+      let connectionRoleRecord = await ctx.db.getRepository("dataSourcesRoles").findOne({
+        filter: {
+          roleName: name,
+          dataSourceKey
+        }
+      });
+      if (!connectionRoleRecord) {
+        connectionRoleRecord = await ctx.db.getRepository("dataSourcesRoles").create({
+          values: {
+            ...params.values,
+            roleName: name,
+            dataSourceKey
+          }
+        });
+      } else {
+        await connectionRoleRecord.update({
+          ...params.values
+        });
+      }
+      ctx.body = connectionRoleRecord.toJSON();
+      await next();
+    },
+    async get(ctx, next) {
+      const params = ctx.action.params;
+      const { filterByTk: name, associatedIndex: dataSourceKey } = params;
+      let connectionRoleRecord = await ctx.db.getRepository("dataSourcesRoles").findOne({
+        filter: {
+          roleName: name,
+          dataSourceKey
+        }
+      });
+      if (!connectionRoleRecord) {
+        connectionRoleRecord = await ctx.db.getRepository("dataSourcesRoles").create({
+          values: {
+            roleName: name,
+            dataSourceKey
+          }
+        });
+      }
+      ctx.body = connectionRoleRecord.toJSON();
+      await next();
+    }
+  }
+};

package/dist/server/resourcers/roles-data-sources-collections.d.ts

@@ -0,0 +1,7 @@
+declare const rolesRemoteCollectionsResourcer: {
+    name: string;
+    actions: {
+        list(ctx: any, next: any): Promise<void>;
+    };
+};
+export { rolesRemoteCollectionsResourcer };

package/dist/server/resourcers/roles-data-sources-collections.js

@@ -0,0 +1,101 @@
+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 roles_data_sources_collections_exports = {};
+__export(roles_data_sources_collections_exports, {
+  rolesRemoteCollectionsResourcer: () => rolesRemoteCollectionsResourcer
+});
+module.exports = __toCommonJS(roles_data_sources_collections_exports);
+var import_full_data_repository = require("../services/full-data-repository");
+var import_lodash = __toESM(require("lodash"));
+function totalPage(total, pageSize) {
+  return Math.ceil(total / pageSize);
+}
+const rolesRemoteCollectionsResourcer = {
+  name: "roles.dataSourcesCollections",
+  actions: {
+    async list(ctx, next) {
+      var _a, _b;
+      const role = ctx.action.params.associatedIndex;
+      const { page = 1, pageSize = 20 } = ctx.action.params;
+      const { filter } = ctx.action.params;
+      const { dataSourceKey } = filter;
+      const dataSource = ctx.app.dataSourceManager.dataSources.get(dataSourceKey);
+      const collectionRepository = new import_full_data_repository.FullDataRepository(dataSource.collectionManager.getCollections());
+      const [collections, count] = await collectionRepository.findAndCount();
+      const filterItem = import_lodash.default.get(filter, "$and");
+      const filterByTitle = filterItem == null ? void 0 : filterItem.find((item) => item.title);
+      const filterByName = filterItem == null ? void 0 : filterItem.find((item) => item.name);
+      const filterTitle = (_a = import_lodash.default.get(filterByTitle, "title.$includes")) == null ? void 0 : _a.toLowerCase();
+      const filterName = (_b = import_lodash.default.get(filterByName, "name.$includes")) == null ? void 0 : _b.toLowerCase();
+      const roleResources = await ctx.app.db.getRepository("dataSourcesRolesResources").find({
+        filter: {
+          roleName: role,
+          dataSourceKey
+        }
+      });
+      const roleResourcesNames = roleResources.map((roleResource) => roleResource.get("name"));
+      const roleResourceActionResourceNames = roleResources.filter((roleResources2) => roleResources2.get("usingActionsConfig")).map((roleResources2) => roleResources2.get("name"));
+      const items = import_lodash.default.sortBy(
+        collections.filter((collection) => {
+          var _a2;
+          return (!filterTitle || ((_a2 = import_lodash.default.get(collection, "options.title")) == null ? void 0 : _a2.toLowerCase().includes(filterTitle))) && (!filterName || collection.options.name.toLowerCase().includes(filterName));
+        }).map((collection, i) => {
+          var _a2;
+          const collectionName = collection.options.name;
+          const exists = roleResourcesNames.includes(collectionName);
+          const usingConfig = roleResourceActionResourceNames.includes(collectionName) ? "resourceAction" : "strategy";
+          return {
+            type: "collection",
+            name: collectionName,
+            collectionName,
+            title: ((_a2 = collection.options.uiSchema) == null ? void 0 : _a2.title) || collection.options.title,
+            roleName: role,
+            usingConfig,
+            exists,
+            fields: [...collection.fields.values()].map((field) => {
+              return field.options;
+            })
+          };
+        }),
+        "name"
+      );
+      ctx.body = {
+        count,
+        rows: items,
+        page: Number(page),
+        pageSize: Number(pageSize),
+        totalPage: totalPage(count, pageSize)
+      };
+      await next();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rolesRemoteCollectionsResourcer
+});

package/dist/server/services/collection-manager.d.ts

@@ -0,0 +1,6 @@
+import { Database } from '@nocobase/database';
+export declare class CollectionManager {
+    private db;
+    constructor(db: Database);
+    findAndCount(): void;
+}

package/dist/server/services/collection-manager.js

@@ -0,0 +1,33 @@
+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 collection_manager_exports = {};
+__export(collection_manager_exports, {
+  CollectionManager: () => CollectionManager
+});
+module.exports = __toCommonJS(collection_manager_exports);
+class CollectionManager {
+  constructor(db) {
+    this.db = db;
+  }
+  findAndCount() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionManager
+});

package/dist/server/services/database-introspector.d.ts

@@ -0,0 +1,70 @@
+import { Database } from '@nocobase/database';
+type tableInfo = {
+    tableName: string;
+    schema?: string;
+};
+type GetCollectionOptions = {
+    tableInfo: tableInfo;
+    localOptions?: PartialCollectionOptions;
+};
+export type LocalData = {
+    [collectionName: string]: PartialCollectionOptions;
+};
+type GetCollectionsOptions = {
+    localData?: LocalData;
+};
+export type PartialCollectionOptions = Partial<Omit<CollectionOptions, 'fields'> & {
+    fields?: Partial<FieldOptions>[];
+}>;
+interface CollectionOptions {
+    name: string;
+    schema?: string;
+    tableName: string;
+    title?: string;
+    timestamps?: boolean;
+    filterTargetKey?: string;
+    fields: FieldOptions[];
+    unsupportedFields?: UnsupportedFieldOptions[];
+}
+interface UnsupportedFieldOptions {
+    rawType: string;
+    name: string;
+    supported: false;
+}
+interface FieldOptions {
+    name: string;
+    field: string;
+    rawType: string;
+    type: string;
+    description?: string;
+    interface?: string;
+    uiSchema?: any;
+    possibleTypes?: string[];
+    defaultValue?: any;
+    primaryKey: boolean;
+    unique: boolean;
+    allowNull?: boolean;
+    autoIncrement?: boolean;
+}
+export declare class DatabaseIntrospector {
+    private db;
+    constructor(db: Database);
+    getCollections(options?: GetCollectionsOptions): Promise<Array<CollectionOptions>>;
+    getCollection(options: GetCollectionOptions): Promise<CollectionOptions>;
+    loadCollection(options: CollectionOptions): void;
+    loadCollections(options: {
+        collections: CollectionOptions[];
+    }): void;
+    tableInfoToCollectionOptions(tableInfo: tableInfo): {
+        name: string;
+        schema?: string;
+        tableName: string;
+        title?: string;
+    };
+    private collectionOptionsByFields;
+    private mergeLocalDataIntoCollectionOptions;
+    private columnInfoToFieldOptions;
+    private getDefaultInterfaceByType;
+    private columnAttribute;
+}
+export {};

package/dist/server/services/database-introspector.js

@@ -0,0 +1,235 @@
+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 database_introspector_exports = {};
+__export(database_introspector_exports, {
+  DatabaseIntrospector: () => DatabaseIntrospector
+});
+module.exports = __toCommonJS(database_introspector_exports);
+var import_database = require("@nocobase/database");
+var import_lodash = __toESM(require("lodash"));
+var import_type_interface_map = __toESM(require("./type-interface-map"));
+class DatabaseIntrospector {
+  constructor(db) {
+    this.db = db;
+  }
+  async getCollections(options = {}) {
+    const tableList = await this.db.sequelize.getQueryInterface().showAllTables();
+    const batchSize = 5;
+    const results = [];
+    for (let i = 0; i < tableList.length; i += batchSize) {
+      const batch = tableList.slice(i, i + batchSize);
+      const batchResults = await Promise.all(
+        batch.map(async (tableName) => {
+          var _a;
+          const tableInfo = {
+            tableName
+          };
+          const collectionOptions = this.tableInfoToCollectionOptions(tableInfo);
+          const localOptions = (_a = options.localData) == null ? void 0 : _a[collectionOptions.name];
+          try {
+            return await this.getCollection({
+              tableInfo,
+              localOptions
+            });
+          } catch (e) {
+            if (e.message.includes("No description found for")) {
+              return false;
+            }
+            throw e;
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return results.filter(Boolean);
+  }
+  async getCollection(options) {
+    const { tableInfo } = options;
+    const columnsInfo = await this.db.sequelize.getQueryInterface().describeTable(tableInfo);
+    const collectionOptions = this.tableInfoToCollectionOptions(tableInfo);
+    const constraints = await this.db.sequelize.getQueryInterface().showIndex(this.db.inDialect("postgres") ? tableInfo : tableInfo.tableName);
+    try {
+      const fields = Object.keys(columnsInfo).map((columnName) => {
+        return this.columnInfoToFieldOptions(columnsInfo, columnName, constraints);
+      });
+      const unsupportedFields = fields.filter((field) => {
+        return field.supported === false;
+      });
+      const supportFields = fields.filter((field) => {
+        return field.supported !== false;
+      });
+      const remoteCollectionInfo = {
+        ...collectionOptions,
+        ...this.collectionOptionsByFields(supportFields),
+        fields: supportFields
+      };
+      if (unsupportedFields.length) {
+        remoteCollectionInfo.unsupportedFields = unsupportedFields;
+      }
+      return this.mergeLocalDataIntoCollectionOptions(remoteCollectionInfo, options.localOptions);
+    } catch (e) {
+      throw new Error(`table ${tableInfo.tableName} introspection error: ${e.message}`);
+    }
+  }
+  loadCollection(options) {
+    this.db.collection({
+      ...options,
+      introspected: true
+    });
+  }
+  loadCollections(options) {
+    options.collections.forEach((collection) => {
+      this.loadCollection(collection);
+    });
+  }
+  tableInfoToCollectionOptions(tableInfo) {
+    return {
+      name: tableInfo.tableName,
+      title: tableInfo.tableName,
+      schema: tableInfo.schema,
+      tableName: tableInfo.tableName
+    };
+  }
+  collectionOptionsByFields(fields) {
+    const options = {
+      timestamps: false
+    };
+    const autoIncrementField = fields.find((field) => field.autoIncrement);
+    if (autoIncrementField) {
+      options.filterTargetKey = autoIncrementField.name;
+    }
+    const primaryKeys = fields.filter((field) => field.primaryKey);
+    if (!options.filterTargetKey && primaryKeys.length == 1) {
+      options.filterTargetKey = primaryKeys[0].name;
+    }
+    const uniques = fields.filter((field) => field.unique);
+    if (!options.filterTargetKey && uniques.length == 1) {
+      options.filterTargetKey = uniques[0].name;
+    }
+    return options;
+  }
+  mergeLocalDataIntoCollectionOptions(collectionOptions, localData) {
+    var _a;
+    if (!localData) {
+      return collectionOptions;
+    }
+    const collectionFields = collectionOptions.fields || [];
+    const localFieldsAsObject = import_lodash.default.keyBy(localData.fields, "name");
+    const newFields = collectionFields.map((field) => {
+      const localField = localFieldsAsObject[field.name];
+      if (!localField) {
+        return field;
+      }
+      return {
+        ...field,
+        ...localField
+      };
+    });
+    const localAssociationFields = (_a = localData.fields) == null ? void 0 : _a.filter((field) => {
+      return ["belongsTo", "belongsToMany", "hasMany", "hasOne"].includes(field.type);
+    });
+    if (localAssociationFields) {
+      newFields.push(...localAssociationFields);
+    }
+    return {
+      ...collectionOptions,
+      ...import_lodash.default.omit(localData, ["fields"]),
+      fields: newFields
+    };
+  }
+  columnInfoToFieldOptions(columnsInfo, columnName, indexes) {
+    const columnInfo = columnsInfo[columnName];
+    let fieldOptions = {
+      ...this.columnAttribute(columnsInfo, columnName, indexes),
+      ...import_database.ViewFieldInference.inferToFieldType({
+        dialect: this.db.options.dialect,
+        type: columnInfo.type,
+        name: columnName
+      }),
+      rawType: columnInfo.type,
+      name: columnName
+    };
+    const interfaceConfig = this.getDefaultInterfaceByType(columnsInfo, columnName, fieldOptions.type);
+    if (typeof interfaceConfig === "string") {
+      fieldOptions.interface = interfaceConfig;
+    } else {
+      fieldOptions = {
+        ...fieldOptions,
+        ...interfaceConfig
+      };
+    }
+    if (!fieldOptions.type) {
+      return {
+        rawType: columnInfo.type,
+        name: columnName,
+        supported: false
+      };
+    }
+    import_lodash.default.set(fieldOptions, "uiSchema.title", columnName);
+    return fieldOptions;
+  }
+  getDefaultInterfaceByType(columnsInfo, columnName, type) {
+    const interfaceConfig = import_type_interface_map.default[type];
+    if (typeof interfaceConfig === "function") {
+      return interfaceConfig(columnsInfo[columnName]);
+    }
+    return interfaceConfig;
+  }
+  columnAttribute(columnsInfo, columnName, indexes) {
+    const columnInfo = columnsInfo[columnName];
+    const attr = {
+      type: columnInfo.type,
+      allowNull: columnInfo.allowNull,
+      primaryKey: columnInfo.primaryKey,
+      unique: false
+    };
+    if (columnInfo.defaultValue && typeof columnInfo.defaultValue === "string") {
+      const isSerial = columnInfo.defaultValue.match(/^nextval\(/);
+      const isUUID = columnInfo.defaultValue.match(/^uuid_generate_v4\(/);
+      if (!isSerial && !isUUID) {
+        attr.defaultValue = columnInfo.defaultValue;
+      }
+      if (isSerial || isUUID) {
+        attr.autoIncrement = true;
+      }
+    }
+    for (const index of indexes) {
+      if (index.fields.length == 1 && index.fields[0].attribute == columnName && index.unique) {
+        attr.unique = true;
+      }
+    }
+    if (attr.primaryKey && columnName == "id") {
+      attr.autoIncrement = true;
+    }
+    return attr;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseIntrospector
+});

package/dist/server/services/full-data-repository.d.ts

@@ -0,0 +1,8 @@
+import { CountOptions, FindOptions } from '@nocobase/database';
+export declare class FullDataRepository<T> {
+    data: Array<T>;
+    constructor(data: Array<T>);
+    count(countOptions?: CountOptions): Promise<number>;
+    find(options?: FindOptions): Promise<Array<T>>;
+    findAndCount(options?: {}): Promise<[Array<T>, number]>;
+}

package/dist/server/services/full-data-repository.js

@@ -0,0 +1,51 @@
+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 full_data_repository_exports = {};
+__export(full_data_repository_exports, {
+  FullDataRepository: () => FullDataRepository
+});
+module.exports = __toCommonJS(full_data_repository_exports);
+class FullDataRepository {
+  data = [];
+  constructor(data) {
+    this.data = data;
+  }
+  async count(countOptions) {
+    return this.data.length;
+  }
+  async find(options) {
+    const { limit, offset } = options || {};
+    let results = this.data;
+    if (offset) {
+      results = results.slice(offset);
+    }
+    if (limit) {
+      results = results.slice(0, limit);
+    }
+    return results;
+  }
+  async findAndCount(options = {}) {
+    const count = await this.count();
+    const results = count ? await this.find(options) : [];
+    return [results, count];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FullDataRepository
+});