@tachybase/database 0.23.8

package/lib/database-utils/index.js

@@ -0,0 +1,71 @@
+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 __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 database_utils_exports = {};
+__export(database_utils_exports, {
+  default: () => DatabaseUtils
+});
+module.exports = __toCommonJS(database_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+__reExport(database_utils_exports, require("./traverseJSON"), module.exports);
+const _DatabaseUtils = class _DatabaseUtils {
+  constructor(db) {
+    this.db = db;
+  }
+  addSchema(tableName, schema) {
+    if (!this.db.inDialect("postgres")) return tableName;
+    if (this.db.options.schema && !schema) {
+      schema = this.db.options.schema;
+    }
+    if (schema) {
+      tableName = this.db.sequelize.getQueryInterface().queryGenerator.addSchema({
+        tableName,
+        _schema: schema
+      });
+    }
+    return tableName;
+  }
+  quoteTable(tableName) {
+    const queryGenerator = this.db.sequelize.getQueryInterface().queryGenerator;
+    tableName = queryGenerator.quoteTable(import_lodash.default.isPlainObject(tableName) ? tableName : this.addSchema(tableName));
+    return tableName;
+  }
+  schema() {
+    if (!this.db.inDialect("postgres")) {
+      return void 0;
+    }
+    return this.db.options.schema || "public";
+  }
+};
+__name(_DatabaseUtils, "DatabaseUtils");
+let DatabaseUtils = _DatabaseUtils;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./traverseJSON")
+});

package/lib/database-utils/traverseJSON.d.ts

@@ -0,0 +1,10 @@
+import { Collection } from '../collection';
+type TraverseOptions = {
+    collection: Collection;
+    exclude?: string[];
+    include?: string[];
+    through?: string;
+    excludePk?: boolean;
+};
+export declare const traverseJSON: (data: any, options: TraverseOptions) => any;
+export {};

package/lib/database-utils/traverseJSON.js

@@ -0,0 +1,126 @@
+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 traverseJSON_exports = {};
+__export(traverseJSON_exports, {
+  traverseJSON: () => traverseJSON
+});
+module.exports = __toCommonJS(traverseJSON_exports);
+const traverseHasMany = /* @__PURE__ */ __name((arr, { collection, exclude = [], include = [] }) => {
+  if (!arr) {
+    return arr;
+  }
+  return arr.map((item) => traverseJSON(item, { collection, exclude, include }));
+}, "traverseHasMany");
+const traverseBelongsToMany = /* @__PURE__ */ __name((arr, { collection, exclude = [], through }) => {
+  if (!arr) {
+    return arr;
+  }
+  const throughCollection = collection.db.getCollection(through);
+  return arr.map((item) => {
+    const data = traverseJSON(item[through], { collection: throughCollection, exclude });
+    if (data && Object.keys(data).length) {
+      item[through] = data;
+    } else {
+      delete item[through];
+    }
+    return traverseJSON(item, {
+      collection,
+      excludePk: false
+    });
+  });
+}, "traverseBelongsToMany");
+const parseInclude = /* @__PURE__ */ __name((keys) => {
+  const map = {};
+  for (const key of keys) {
+    const args = key.split(".");
+    const field = args.shift();
+    map[field] = map[field] || [];
+    if (args.length) {
+      map[field].push(args.join("."));
+    }
+  }
+  return map;
+}, "parseInclude");
+const traverseJSON = /* @__PURE__ */ __name((data, options) => {
+  if (!data) {
+    return data;
+  }
+  const { collection, exclude = [], include = [], excludePk = true } = options;
+  const map = parseInclude(include);
+  const result = {};
+  for (const key of Object.keys(data || {})) {
+    const subInclude = map[key];
+    if (include.length > 0 && !subInclude) {
+      continue;
+    }
+    if (exclude.includes(key)) {
+      continue;
+    }
+    if (["createdAt", "updatedAt", "createdBy", "createdById", "updatedById", "updatedBy"].includes(key)) {
+      continue;
+    }
+    const field = collection.getField(key);
+    if (!field) {
+      result[key] = data[key];
+      continue;
+    }
+    if (field.options.primaryKey && excludePk) {
+      continue;
+    }
+    if (field.options.isForeignKey) {
+      continue;
+    }
+    if (["sort", "password", "sequence"].includes(field.type)) {
+      continue;
+    }
+    if (field.type === "hasOne") {
+      result[key] = traverseJSON(data[key], {
+        collection: collection.db.getCollection(field.target),
+        exclude: [field.foreignKey],
+        include: subInclude
+      });
+    } else if (field.type === "hasMany") {
+      result[key] = traverseHasMany(data[key], {
+        collection: collection.db.getCollection(field.target),
+        exclude: [field.foreignKey],
+        include: subInclude
+      });
+    } else if (field.type === "belongsTo") {
+      result[key] = traverseJSON(data[key], {
+        collection: collection.db.getCollection(field.target),
+        // exclude: [field.foreignKey],
+        include: subInclude,
+        excludePk: false
+      });
+    } else if (field.type === "belongsToMany") {
+      result[key] = traverseBelongsToMany(data[key], {
+        collection: collection.db.getCollection(field.target),
+        exclude: [field.foreignKey, field.otherKey],
+        through: field.through
+      });
+    } else {
+      result[key] = data[key];
+    }
+  }
+  return result;
+}, "traverseJSON");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  traverseJSON
+});

package/lib/database.d.ts

@@ -0,0 +1,201 @@
+import { EventEmitter } from 'events';
+import { Logger, LoggerOptions } from '@tachybase/logger';
+import { AsyncEmitter } from '@tachybase/utils';
+import merge from 'deepmerge';
+import { ModelStatic, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions, Transactionable } from 'sequelize';
+import { ConnectionManager } from 'sequelize/types/dialects/abstract/connection-manager';
+import { Umzug } from 'umzug';
+import { Collection, CollectionOptions, RepositoryType } from './collection';
+import { CollectionFactory } from './collection-factory';
+import { CollectionGroupManager } from './collection-group-manager';
+import { ImportFileExtension } from './collection-importer';
+import DatabaseUtils from './database-utils';
+import ReferencesMap from './features/references-map';
+import { ArrayFieldRepository } from './field-repository/array-field-repository';
+import * as FieldTypes from './fields';
+import { Field, FieldContext, RelationField } from './fields';
+import InheritanceMap from './inherited-map';
+import { MigrationItem, Migrations } from './migration';
+import { Model } from './model';
+import { ModelHook } from './model-hook';
+import QueryInterface from './query-interface/query-interface';
+import { RelationRepository } from './relation-repository/relation-repository';
+import { Repository } from './repository';
+import { AfterDefineCollectionListener, BeforeDefineCollectionListener, CreateListener, CreateWithAssociationsListener, DatabaseAfterDefineCollectionEventType, DatabaseAfterRemoveCollectionEventType, DatabaseBeforeDefineCollectionEventType, DatabaseBeforeRemoveCollectionEventType, DestroyListener, EventType, ModelCreateEventTypes, ModelCreateWithAssociationsEventTypes, ModelDestroyEventTypes, ModelSaveEventTypes, ModelSaveWithAssociationsEventTypes, ModelUpdateEventTypes, ModelUpdateWithAssociationsEventTypes, ModelValidateEventTypes, RemoveCollectionListener, SaveListener, SaveWithAssociationsListener, SyncListener, UpdateListener, UpdateWithAssociationsListener, ValidateListener } from './types';
+import { BaseValueParser } from './value-parsers';
+export type MergeOptions = merge.Options;
+export interface PendingOptions {
+    field: RelationField;
+    model: ModelStatic<Model>;
+}
+interface MapOf<T> {
+    [key: string]: T;
+}
+export interface IDatabaseOptions extends Options {
+    tablePrefix?: string;
+    migrator?: any;
+    usingBigIntForId?: boolean;
+    underscored?: boolean;
+    logger?: LoggerOptions | Logger;
+    customHooks?: any;
+    instanceId?: string;
+}
+export type DatabaseOptions = IDatabaseOptions;
+interface RegisterOperatorsContext {
+    db?: Database;
+    path?: string;
+    field?: Field;
+    app?: any;
+}
+export interface CleanOptions extends QueryInterfaceDropAllTablesOptions {
+    drop?: boolean;
+}
+export type AddMigrationsOptions = {
+    context?: any;
+    namespace?: string;
+    extensions?: string[];
+    directory: string;
+};
+type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
+export declare const DialectVersionAccessors: {
+    sqlite: {
+        sql: string;
+        get: (v: string) => string;
+    };
+    mysql: {
+        sql: string;
+        get: (v: string) => string;
+    };
+    mariadb: {
+        sql: string;
+        get: (v: string) => string;
+    };
+    postgres: {
+        sql: string;
+        get: (v: string) => any;
+    };
+};
+declare class DatabaseVersion {
+    db: Database;
+    constructor(db: Database);
+    satisfies(versions: any): Promise<any>;
+}
+declare module 'sequelize' {
+    interface Sequelize {
+        dialect: any;
+        readonly connectionManager: ConnectionManager;
+    }
+}
+export declare class Database extends EventEmitter implements AsyncEmitter {
+    sequelize: Sequelize;
+    migrator: Umzug;
+    migrations: Migrations;
+    fieldTypes: Map<any, any>;
+    fieldValueParsers: Map<any, any>;
+    options: IDatabaseOptions;
+    models: Map<string, ModelStatic<Model<any, any>>>;
+    repositories: Map<string, typeof Repository>;
+    operators: Map<any, any>;
+    collections: Map<string, Collection<any, any>>;
+    pendingFields: Map<string, FieldTypes.RelationField[]>;
+    modelCollection: Map<ModelStatic<any>, Collection<any, any>>;
+    tableNameCollectionMap: Map<string, Collection<any, any>>;
+    context: any;
+    queryInterface: QueryInterface;
+    utils: DatabaseUtils;
+    referenceMap: ReferencesMap;
+    inheritanceMap: InheritanceMap;
+    importedFrom: Map<string, Set<string>>;
+    modelHook: ModelHook;
+    version: DatabaseVersion;
+    delayCollectionExtend: Map<string, {
+        collectionOptions: CollectionOptions;
+        mergeOptions?: any;
+    }[]>;
+    logger: Logger;
+    collectionGroupManager: CollectionGroupManager;
+    collectionFactory: CollectionFactory;
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+    constructor(options: DatabaseOptions);
+    _instanceId: string;
+    get instanceId(): string;
+    createMigrator({ migrations }: {
+        migrations: any;
+    }): Umzug<any>;
+    setContext(context: any): void;
+    sequelizeOptions(options: any): any;
+    initListener(): void;
+    addMigration(item: MigrationItem): void;
+    addMigrations(options: AddMigrationsOptions): void;
+    inDialect(...dialect: string[]): boolean;
+    isMySQLCompatibleDialect(): boolean;
+    /**
+     * Add collection to database
+     * @param options
+     */
+    collection<Attributes = any, CreateAttributes = Attributes>(options: CollectionOptions): Collection<Attributes, CreateAttributes>;
+    getTablePrefix(): string;
+    getFieldByPath(path: string): any;
+    /**
+     * get exists collection by its name
+     * @param name
+     */
+    getCollection(name: string): Collection;
+    hasCollection(name: string): boolean;
+    removeCollection(name: string): Collection<any, any>;
+    getModel<M extends Model>(name: string): ModelStatic<M>;
+    getRepository<R extends Repository>(name: string): R;
+    getRepository<R extends RelationRepository>(name: string, relationId: string | number): R;
+    getRepository<R extends ArrayFieldRepository>(name: string, relationId: string | number): R;
+    addPendingField(field: RelationField): void;
+    removePendingField(field: RelationField): void;
+    registerFieldTypes(fieldTypes: MapOf<typeof Field>): void;
+    registerFieldValueParsers(parsers: MapOf<any>): void;
+    buildFieldValueParser<T extends BaseValueParser>(field: Field, ctx: any): T;
+    registerModels(models: MapOf<ModelStatic<any>>): void;
+    registerRepositories(repositories: MapOf<RepositoryType>): void;
+    initOperators(): void;
+    registerOperators(operators: MapOf<OperatorFunc>): void;
+    buildField(options: any, context: FieldContext): any;
+    sync(options?: SyncOptions): Promise<Sequelize>;
+    clean(options: CleanOptions): Promise<void>;
+    collectionExistsInDb(name: string, options?: Transactionable): Promise<boolean>;
+    isSqliteMemory(): boolean;
+    auth(options?: Omit<QueryOptions, 'retry'> & {
+        retry?: number | Pick<QueryOptions, 'retry'>;
+    }): Promise<void>;
+    checkVersion(): Promise<boolean>;
+    prepare(): Promise<void>;
+    reconnect(): Promise<void>;
+    closed(): any;
+    close(): Promise<void>;
+    on(event: EventType, listener: any): this;
+    on(event: ModelValidateEventTypes, listener: SyncListener): this;
+    on(event: ModelValidateEventTypes, listener: ValidateListener): this;
+    on(event: ModelCreateEventTypes, listener: CreateListener): this;
+    on(event: ModelUpdateEventTypes, listener: UpdateListener): this;
+    on(event: ModelSaveEventTypes, listener: SaveListener): this;
+    on(event: ModelDestroyEventTypes, listener: DestroyListener): this;
+    on(event: ModelCreateWithAssociationsEventTypes, listener: CreateWithAssociationsListener): this;
+    on(event: ModelUpdateWithAssociationsEventTypes, listener: UpdateWithAssociationsListener): this;
+    on(event: ModelSaveWithAssociationsEventTypes, listener: SaveWithAssociationsListener): this;
+    on(event: DatabaseBeforeDefineCollectionEventType, listener: BeforeDefineCollectionListener): this;
+    on(event: DatabaseAfterDefineCollectionEventType, listener: AfterDefineCollectionListener): this;
+    on(event: DatabaseBeforeRemoveCollectionEventType | DatabaseAfterRemoveCollectionEventType, listener: RemoveCollectionListener): this;
+    extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): void;
+    import(options: {
+        directory: string;
+        from?: string;
+        extensions?: ImportFileExtension[];
+    }): Promise<Map<string, Collection>>;
+    private registerCollectionType;
+}
+export declare type CollectionDef = {
+    collectionOptions: CollectionOptions;
+    mergeOptions: MergeOptions;
+    extend: boolean;
+};
+export declare function extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): CollectionDef;
+export declare const extend: typeof extendCollection;
+export declare const defineCollection: (collectionOptions: CollectionOptions) => CollectionOptions;
+export default Database;