@tachybase/database 0.23.8

package/lib/relation-repository/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/lib/repositories/tree-repository/adjacency-list-repository.d.ts

@@ -0,0 +1,18 @@
+import { Collection } from '../../collection';
+import Database from '../../database';
+import { FindOptions, Repository } from '../../repository';
+export declare class AdjacencyListRepository extends Repository {
+    static queryParentSQL(options: {
+        db: Database;
+        nodeIds: any[];
+        collection: Collection;
+        foreignKey: string;
+        targetKey: string;
+    }): string;
+    update(options: any): Promise<any>;
+    find(options?: FindOptions & {
+        addIndex?: boolean;
+    }): Promise<any>;
+    private addIndex;
+    private querySQL;
+}

package/lib/repositories/tree-repository/adjacency-list-repository.js

@@ -0,0 +1,183 @@
+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 adjacency_list_repository_exports = {};
+__export(adjacency_list_repository_exports, {
+  AdjacencyListRepository: () => AdjacencyListRepository
+});
+module.exports = __toCommonJS(adjacency_list_repository_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_repository = require("../../repository");
+const _AdjacencyListRepository = class _AdjacencyListRepository extends import_repository.Repository {
+  static queryParentSQL(options) {
+    const { collection, db, nodeIds } = options;
+    const tableName = collection.quotedTableName();
+    const { foreignKey, targetKey } = options;
+    const foreignKeyField = collection.model.rawAttributes[foreignKey].field;
+    const targetKeyField = collection.model.rawAttributes[targetKey].field;
+    const queryInterface = db.sequelize.getQueryInterface();
+    const q = queryInterface.quoteIdentifier.bind(queryInterface);
+    return `WITH RECURSIVE cte AS (
+      SELECT ${q(targetKeyField)}, ${q(foreignKeyField)}
+      FROM ${tableName}
+      WHERE ${q(targetKeyField)} IN (${nodeIds.join(",")})
+      UNION ALL
+      SELECT t.${q(targetKeyField)}, t.${q(foreignKeyField)}
+      FROM ${tableName} AS t
+      INNER JOIN cte ON t.${q(targetKeyField)} = cte.${q(foreignKeyField)}
+      )
+      SELECT ${q(targetKeyField)} AS ${q(targetKey)}, ${q(foreignKeyField)} AS ${q(foreignKey)} FROM cte`;
+  }
+  async update(options) {
+    return super.update({
+      ...options || {},
+      addIndex: false
+    });
+  }
+  async find(options = {}) {
+    var _a;
+    if (options.raw || !options.tree) {
+      return await super.find(options);
+    }
+    const collection = this.collection;
+    const primaryKey = collection.model.primaryKeyAttribute;
+    if (options.fields && !options.fields.includes(primaryKey)) {
+      options.fields.push(primaryKey);
+    }
+    const parentNodes = await super.find(options);
+    if (parentNodes.length === 0) {
+      return [];
+    }
+    const { treeParentField } = collection;
+    const foreignKey = treeParentField.options.foreignKey;
+    const childrenKey = ((_a = collection.treeChildrenField) == null ? void 0 : _a.name) ?? "children";
+    const parentIds = parentNodes.map((node) => node[primaryKey]);
+    if (parentIds.length == 0) {
+      this.database.logger.warn("parentIds is empty");
+      return parentNodes;
+    }
+    const sql = this.querySQL(parentIds, collection);
+    const childNodes = await this.database.sequelize.query(sql, {
+      type: "SELECT",
+      transaction: options.transaction
+    });
+    const childIds = childNodes.map((node) => node[primaryKey]);
+    const findChildrenOptions = {
+      ...import_lodash.default.omit(options, ["limit", "offset", "filterByTk"]),
+      filter: {
+        [primaryKey]: childIds
+      }
+    };
+    if (findChildrenOptions.fields) {
+      [primaryKey, foreignKey].forEach((field) => {
+        if (!findChildrenOptions.fields.includes(field)) {
+          findChildrenOptions.fields.push(field);
+        }
+      });
+    }
+    const childInstances = await super.find(findChildrenOptions);
+    const nodeMap = {};
+    childInstances.forEach((node) => {
+      if (!nodeMap[`${node[foreignKey]}`]) {
+        nodeMap[`${node[foreignKey]}`] = [];
+      }
+      nodeMap[`${node[foreignKey]}`].push(node);
+    });
+    function buildTree(parentId) {
+      const children = nodeMap[parentId];
+      if (!children) {
+        return [];
+      }
+      return children.map((child) => {
+        const childrenValues = buildTree(child.id);
+        if (childrenValues.length > 0) {
+          child.setDataValue(childrenKey, childrenValues);
+        }
+        return child;
+      });
+    }
+    __name(buildTree, "buildTree");
+    for (const parent of parentNodes) {
+      const parentId = parent[primaryKey];
+      const children = buildTree(parentId);
+      if (children.length > 0) {
+        parent.setDataValue(childrenKey, children);
+      }
+    }
+    this.addIndex(parentNodes, childrenKey, options);
+    return parentNodes;
+  }
+  addIndex(treeArray, childrenKey, options) {
+    function traverse(node, index) {
+      if (node._options.includeNames && !node._options.includeNames.includes(childrenKey)) {
+        node._options.includeNames.push(childrenKey);
+      }
+      if (options.addIndex !== false) {
+        node.setDataValue("__index", `${index}`);
+      }
+      const children = node.getDataValue(childrenKey);
+      if (children && children.length === 0) {
+        node.setDataValue(childrenKey, void 0);
+      }
+      if (children && children.length > 0) {
+        children.forEach((child, i) => {
+          traverse(child, `${index}.${childrenKey}.${i}`);
+        });
+      }
+    }
+    __name(traverse, "traverse");
+    treeArray.forEach((tree, i) => {
+      traverse(tree, i);
+    });
+  }
+  querySQL(rootIds, collection) {
+    const { treeParentField } = collection;
+    const foreignKey = treeParentField.options.foreignKey;
+    const foreignKeyField = collection.model.rawAttributes[foreignKey].field;
+    const primaryKey = collection.model.primaryKeyAttribute;
+    const queryInterface = this.database.sequelize.getQueryInterface();
+    const q = queryInterface.quoteIdentifier.bind(queryInterface);
+    return `
+      WITH RECURSIVE cte AS (SELECT ${q(primaryKey)}, ${q(foreignKeyField)}, 1 AS level
+                             FROM ${collection.quotedTableName()}
+                             WHERE ${q(foreignKeyField)} IN (${rootIds.join(",")})
+                             UNION ALL
+                             SELECT t.${q(primaryKey)}, t.${q(foreignKeyField)}, cte.level + 1 AS level
+                             FROM ${collection.quotedTableName()} t
+                                    JOIN cte ON t.${q(foreignKeyField)} = cte.${q(primaryKey)})
+      SELECT ${q(primaryKey)}, ${q(foreignKeyField)} as ${q(foreignKey)}, level
+      FROM cte
+    `;
+  }
+};
+__name(_AdjacencyListRepository, "AdjacencyListRepository");
+let AdjacencyListRepository = _AdjacencyListRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdjacencyListRepository
+});

package/lib/repositories/view-repository.d.ts

@@ -0,0 +1,3 @@
+import { Repository } from '../repository';
+export declare class ViewRepository extends Repository {
+}

package/lib/repositories/view-repository.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 view_repository_exports = {};
+__export(view_repository_exports, {
+  ViewRepository: () => ViewRepository
+});
+module.exports = __toCommonJS(view_repository_exports);
+var import_repository = require("../repository");
+const _ViewRepository = class _ViewRepository extends import_repository.Repository {
+};
+__name(_ViewRepository, "ViewRepository");
+let ViewRepository = _ViewRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ViewRepository
+});

package/lib/repository.d.ts

@@ -0,0 +1,206 @@
+import { Association, BulkCreateOptions, ModelStatic, FindAndCountOptions as SequelizeAndCountOptions, CountOptions as SequelizeCountOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindOptions as SequelizeFindOptions, UpdateOptions as SequelizeUpdateOptions, Transactionable, WhereOperators } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+import { ArrayFieldRepository } from './field-repository/array-field-repository';
+import { Model } from './model';
+import operators from './operators';
+import { BelongsToManyRepository } from './relation-repository/belongs-to-many-repository';
+import { BelongsToRepository } from './relation-repository/belongs-to-repository';
+import { HasManyRepository } from './relation-repository/hasmany-repository';
+import { HasOneRepository } from './relation-repository/hasone-repository';
+import { RelationRepository } from './relation-repository/relation-repository';
+interface CreateManyOptions extends BulkCreateOptions {
+    records: Values[];
+}
+export type { Transactionable } from 'sequelize';
+export interface FilterAble {
+    filter: Filter;
+}
+export type TargetKey = string | number;
+export type TK = TargetKey | TargetKey[];
+type FieldValue = string | number | bigint | boolean | Date | Buffer | null | FieldValue[] | FilterWithOperator;
+type Operators = keyof typeof operators & keyof WhereOperators;
+export type FilterWithOperator = {
+    [key: string]: {
+        [K in Operators]: FieldValue;
+    } | FieldValue;
+};
+export type FilterWithValue = {
+    [key: string]: FieldValue;
+};
+type FilterAnd = {
+    $and: Filter[];
+};
+type FilterOr = {
+    $or: Filter[];
+};
+export type Filter = FilterWithOperator | FilterWithValue | FilterAnd | FilterOr;
+export type Appends = string[];
+export type Except = string[];
+export type Fields = string[];
+export type Sort = string[] | string;
+export type WhiteList = string[];
+export type BlackList = string[];
+export type AssociationKeysToBeUpdate = string[];
+export type Values = any;
+export type CountOptions = Omit<SequelizeCountOptions, 'distinct' | 'where' | 'include'> & Transactionable & {
+    filter?: Filter;
+    context?: any;
+} & FilterByTk;
+export interface FilterByTk {
+    filterByTk?: TargetKey;
+    targetCollection?: string;
+}
+export type FindOptions = SequelizeFindOptions & CommonFindOptions & FilterByTk;
+export interface CommonFindOptions extends Transactionable {
+    filter?: Filter;
+    fields?: Fields;
+    appends?: Appends;
+    except?: Except;
+    sort?: Sort;
+    context?: any;
+    tree?: boolean;
+}
+export type FindOneOptions = Omit<FindOptions, 'limit'> & {
+    targetCollection?: string;
+};
+export interface DestroyOptions extends SequelizeDestroyOptions {
+    filter?: Filter;
+    filterByTk?: TargetKey | TargetKey[];
+    truncate?: boolean;
+    context?: any;
+}
+type FindAndCountOptions = Omit<SequelizeAndCountOptions, 'where' | 'include' | 'order'> & CommonFindOptions;
+export interface CreateOptions extends SequelizeCreateOptions {
+    values?: Values | Values[];
+    whitelist?: WhiteList;
+    blacklist?: BlackList;
+    updateAssociationValues?: AssociationKeysToBeUpdate;
+    context?: any;
+}
+export interface UpdateOptions extends Omit<SequelizeUpdateOptions, 'where'> {
+    values: Values;
+    filter?: Filter;
+    filterByTk?: TargetKey;
+    whitelist?: WhiteList;
+    blacklist?: BlackList;
+    updateAssociationValues?: AssociationKeysToBeUpdate;
+    targetCollection?: string;
+    context?: any;
+    /**
+     * false: will not update updateAt field, default: false
+     * @default false
+     */
+    silent?: boolean;
+}
+interface UpdateManyOptions extends Omit<UpdateOptions, 'values'> {
+    records: Values[];
+}
+declare class RelationRepositoryBuilder<R extends RelationRepository> {
+    collection: Collection;
+    associationName: string;
+    association: Association | {
+        associationType: string;
+    };
+    builderMap: {
+        HasOne: typeof HasOneRepository;
+        BelongsTo: typeof BelongsToRepository;
+        BelongsToMany: typeof BelongsToManyRepository;
+        HasMany: typeof HasManyRepository;
+        ArrayField: typeof ArrayFieldRepository;
+    };
+    constructor(collection: Collection, associationName: string);
+    of(id: string | number): R;
+    protected builder(): {
+        HasOne: typeof HasOneRepository;
+        BelongsTo: typeof BelongsToRepository;
+        BelongsToMany: typeof BelongsToManyRepository;
+        HasMany: typeof HasManyRepository;
+        ArrayField: typeof ArrayFieldRepository;
+    };
+}
+export interface AggregateOptions {
+    method: 'avg' | 'count' | 'min' | 'max' | 'sum';
+    field?: string;
+    filter?: Filter;
+    distinct?: boolean;
+}
+interface FirstOrCreateOptions extends Transactionable {
+    filterKeys: string[];
+    values?: Values;
+    hooks?: boolean;
+}
+export declare class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> {
+    database: Database;
+    collection: Collection;
+    model: ModelStatic<Model>;
+    constructor(collection: Collection);
+    static valuesToFilter(values: Values, filterKeys: Array<string>): {
+        $and: any[];
+    };
+    /**
+     * return count by filter
+     */
+    count(countOptions?: CountOptions): Promise<number>;
+    aggregate(options: AggregateOptions & {
+        optionsTransformer?: (options: any) => any;
+    }): Promise<any>;
+    /**
+     * find
+     * @param options
+     */
+    find(options?: FindOptions): any;
+    /**
+     * find and count
+     * @param options
+     */
+    findAndCount(options?: FindAndCountOptions): Promise<[Model[], number]>;
+    /**
+     * Find By Id
+     *
+     */
+    findById(id: string | number): Promise<Model<any, any>>;
+    /**
+     * Find one record from database
+     *
+     * @param options
+     */
+    findOne(options?: FindOneOptions): Promise<any>;
+    /**
+     * Get the first record matching the attributes or create it.
+     */
+    firstOrCreate(options: FirstOrCreateOptions): Promise<any>;
+    updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
+    /**
+     * Save instance to database
+     *
+     * @param values
+     * @param options
+     */
+    create(options: CreateOptions): Promise<any>;
+    /**
+     * Save Many instances to database
+     *
+     * @param records
+     * @param options
+     */
+    createMany(options: CreateManyOptions): Promise<any[]>;
+    /**
+     * Update model value
+     *
+     * @param values
+     * @param options
+     */
+    update(options: UpdateOptions & {
+        forceUpdate?: boolean;
+    }): Promise<any>;
+    updateMany(options: UpdateManyOptions): Promise<any[]>;
+    destroy(options?: TargetKey | TargetKey[] | DestroyOptions): any;
+    /**
+     * @param association target association
+     */
+    relation<R extends RelationRepository>(association: string): RelationRepositoryBuilder<R>;
+    buildQueryOptions(options: any): any;
+    protected parseFilter(filter: Filter, options?: any): any;
+    protected getTransaction(options: any, autoGen?: boolean): Promise<any>;
+}