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

package/lib/sequelize-collection-manager.d.ts

@@ -0,0 +1,22 @@
+import Database from '@nocobase/database';
+import { CollectionOptions, ICollection, ICollectionManager, IRepository, MergeOptions } from './types';
+export declare class SequelizeCollectionManager implements ICollectionManager {
+    db: Database;
+    options: any;
+    constructor(options: any);
+    collectionsFilter(): any;
+    createDB(options?: any): any;
+    registerFieldTypes(types: Record<string, any>): void;
+    registerFieldInterfaces(): void;
+    registerCollectionTemplates(): void;
+    registerModels(models: Record<string, any>): void;
+    registerRepositories(repositories: Record<string, any>): void;
+    getRegisteredRepository(key: any): any;
+    defineCollection(options: CollectionOptions): import("@nocobase/database").Collection<any, any>;
+    extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): ICollection;
+    hasCollection(name: string): boolean;
+    getCollection(name: string): import("@nocobase/database").Collection<any, any>;
+    getCollections(): import("@nocobase/database").Collection<any, any>[];
+    getRepository<R = IRepository>(name: string, sourceId?: string | number): R;
+    sync(): Promise<void>;
+}

package/lib/sequelize-collection-manager.js

@@ -0,0 +1,106 @@
+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 sequelize_collection_manager_exports = {};
+__export(sequelize_collection_manager_exports, {
+  SequelizeCollectionManager: () => SequelizeCollectionManager
+});
+module.exports = __toCommonJS(sequelize_collection_manager_exports);
+var import_database = __toESM(require("@nocobase/database"));
+const _SequelizeCollectionManager = class _SequelizeCollectionManager {
+  db;
+  options;
+  constructor(options) {
+    this.db = this.createDB(options);
+    this.options = options;
+  }
+  collectionsFilter() {
+    if (this.options.collectionsFilter) {
+      return this.options.collectionsFilter;
+    }
+    return (collection) => {
+      return collection.options.introspected;
+    };
+  }
+  createDB(options = {}) {
+    if (options.database instanceof import_database.default) {
+      return options.database;
+    }
+    return new import_database.default(options);
+  }
+  registerFieldTypes(types) {
+    this.db.registerFieldTypes(types);
+  }
+  registerFieldInterfaces() {
+  }
+  registerCollectionTemplates() {
+  }
+  registerModels(models) {
+    return this.db.registerModels(models);
+  }
+  registerRepositories(repositories) {
+    return this.db.registerModels(repositories);
+  }
+  getRegisteredRepository(key) {
+    if (typeof key !== "string") {
+      return key;
+    }
+    return this.db.repositories.get(key);
+  }
+  defineCollection(options) {
+    const collection = this.db.collection(options);
+    collection.model.refreshAttributes();
+    collection.model._findAutoIncrementAttribute();
+    return collection;
+  }
+  extendCollection(collectionOptions, mergeOptions) {
+    return this.db.extendCollection(collectionOptions, mergeOptions);
+  }
+  hasCollection(name) {
+    return this.db.hasCollection(name);
+  }
+  getCollection(name) {
+    return this.db.getCollection(name);
+  }
+  getCollections() {
+    const collectionsFilter = this.collectionsFilter();
+    return [...this.db.collections.values()].filter((collection) => collectionsFilter(collection));
+  }
+  getRepository(name, sourceId) {
+    return this.db.getRepository(name, sourceId);
+  }
+  async sync() {
+    await this.db.sync();
+  }
+};
+__name(_SequelizeCollectionManager, "SequelizeCollectionManager");
+let SequelizeCollectionManager = _SequelizeCollectionManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SequelizeCollectionManager
+});

package/lib/sequelize-data-source.d.ts

@@ -0,0 +1,6 @@
+import { DataSource } from './data-source';
+import { SequelizeCollectionManager } from './sequelize-collection-manager';
+export declare class SequelizeDataSource extends DataSource {
+    load(): Promise<void>;
+    createCollectionManager(options?: any): SequelizeCollectionManager;
+}

package/lib/sequelize-data-source.js

@@ -0,0 +1,38 @@
+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 sequelize_data_source_exports = {};
+__export(sequelize_data_source_exports, {
+  SequelizeDataSource: () => SequelizeDataSource
+});
+module.exports = __toCommonJS(sequelize_data_source_exports);
+var import_data_source = require("./data-source");
+var import_sequelize_collection_manager = require("./sequelize-collection-manager");
+const _SequelizeDataSource = class _SequelizeDataSource extends import_data_source.DataSource {
+  async load() {
+  }
+  createCollectionManager(options) {
+    return new import_sequelize_collection_manager.SequelizeCollectionManager(options.collectionManager);
+  }
+};
+__name(_SequelizeDataSource, "SequelizeDataSource");
+let SequelizeDataSource = _SequelizeDataSource;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SequelizeDataSource
+});

package/lib/types.d.ts

@@ -0,0 +1,65 @@
+export type CollectionOptions = {
+    name: string;
+    repository?: string;
+    fields: any[];
+    [key: string]: any;
+};
+export type 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;
+    [key: string]: any;
+};
+export interface IField {
+    options: FieldOptions;
+}
+export interface ICollection {
+    repository: any;
+    updateOptions(options: any): void;
+    setField(name: string, options: any): IField;
+    removeField(name: string): void;
+    getFields(): Array<IField>;
+    getField(name: string): IField;
+    [key: string]: any;
+}
+export interface IModel {
+    [key: string]: any;
+}
+export interface IRepository {
+    find(options?: any): Promise<IModel[]>;
+    findOne(options?: any): Promise<IModel>;
+    count(options?: any): Promise<Number>;
+    findAndCount(options?: any): Promise<[IModel[], Number]>;
+    create(options: any): void;
+    update(options: any): void;
+    destroy(options: any): void;
+    [key: string]: any;
+}
+export type MergeOptions = {
+    [key: string]: any;
+};
+export interface ICollectionManager {
+    registerFieldTypes(types: Record<string, any>): void;
+    registerFieldInterfaces(interfaces: Record<string, any>): void;
+    registerCollectionTemplates(templates: Record<string, any>): void;
+    registerModels(models: Record<string, any>): void;
+    registerRepositories(repositories: Record<string, any>): void;
+    getRegisteredRepository(key: string): IRepository;
+    defineCollection(options: CollectionOptions): ICollection;
+    extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): ICollection;
+    hasCollection(name: string): boolean;
+    getCollection(name: string): ICollection;
+    getCollections(): Array<ICollection>;
+    getRepository(name: string, sourceId?: string | number): IRepository;
+    sync(): Promise<void>;
+}

package/lib/types.js

@@ -0,0 +1,15 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@nocobase/data-source-manager",
+  "version": "0.20.0-alpha.1",
+  "description": "",
+  "license": "Apache-2.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@nocobase/actions": "0.20.0-alpha.1",
+    "@nocobase/cache": "0.20.0-alpha.1",
+    "@nocobase/database": "0.20.0-alpha.1",
+    "@nocobase/resourcer": "0.20.0-alpha.1",
+    "@nocobase/utils": "0.20.0-alpha.1",
+    "@types/jsonwebtoken": "^8.5.8",
+    "jsonwebtoken": "^8.5.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nocobase/nocobase.git",
+    "directory": "packages/auth"
+  },
+  "gitHead": "516c0b1470d77ff499f533ae6b57e4c084450ff5"
+}