@e22m4u/js-repository 0.6.5 → 0.8.0

package/src/filter/filter-clause.d.ts

@@ -1,348 +0,0 @@
-import {ModelData} from '../types.js';
-
-/**
- * Filter clause.
- */
-export declare type FilterClause<M extends object = ModelData> = {
-  where?: WhereClause<M>;
-  order?: OrderClause<M>;
-  limit?: number;
-  skip?: number;
-  fields?: FieldsClause<M>;
-  include?: IncludeClause<M>;
-};
-
-/**
- * Item filter clause.
- */
-export declare type ItemFilterClause<M extends object = ModelData> = Pick<
-  FilterClause<M>,
-  'fields' | 'include'
->;
-
-/**
- * Where clause.
- *
- * @example
- * ```ts
- * value => value.featured === true
- * {foo: 'bar'}
- * {foo: {eq: 'bar'}}
- * {foo: {neq: 'bar'}}
- * {foo: {gt: 5}}
- * {foo: {lt: 10}}
- * {foo: {gte: 5}}
- * {foo: {lte: 10}}
- * {foo: {inq: ['bar', 'baz']}}
- * {foo: {nin: ['bar', 'baz']}}
- * {foo: {between: [5, 10]}}
- * {foo: {exists: true}}
- * {foo: {like: 'bar'}}
- * {foo: {ilike: 'BaR'}}
- * {foo: {nlike: 'bar'}}
- * {foo: {nilike: 'BaR'}}
- * {foo: {regexp: 'ba.+'}}
- * {foo: {regexp: 'ba.+', flags: 'i'}}
- * {and: [...]}
- * {or: [...]}
- * ```
- */
-export declare type WhereClause<M extends object = ModelData> =
-  Partial<AndClause<M>> |
-  Partial<OrClause<M>> |
-  PropertiesClause<M>;
-
-/**
- * Primitive values.
- */
-export declare type PrimitiveValue =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined;
-
-/**
- * Properties clause.
- *
- * @example
- * ```ts
- * {
- *   name: {inq: ['John', 'Mary']},
- *   status: 'ACTIVE',
- *   age: {gte: 40}
- * }
- * ```
- */
-export declare type PropertiesClause<M extends object = ModelData> = {
-  [property in keyof M]?: OperatorClause | PrimitiveValue | RegExp;
-};
-
-/**
- * Operator clause.
- *
- * @example
- * ```ts
- * {eq: 'bar'}
- * {neq: 'bar'}
- * {gt: 5}
- * {lt: 10}
- * {gte: 5}
- * {lte: 10}
- * {inq: ['bar', 'baz']}
- * {nin: ['bar', 'baz']}
- * {between: [5, 10]}
- * {exists: true}
- * {like: 'bar'}
- * {ilike: 'BaR'}
- * {nlike: 'bar'}
- * {nilike: 'BaR'}
- * {regexp: 'ba.+'}
- * {regexp: 'ba.+', flags: 'i'}
- * ```
- */
-export declare type OperatorClause = {
-  eq?: PrimitiveValue;
-  neq?: PrimitiveValue;
-  gt?: string | number;
-  gte?: string | number;
-  lt?: string | number;
-  lte?: string | number;
-  inq?: PrimitiveValue[];
-  nin?: PrimitiveValue[];
-  between?: readonly [string | number, string | number];
-  exists?: boolean;
-  like?: string;
-  nlike?: string;
-  ilike?: string;
-  nilike?: string;
-  regexp?: string | RegExp;
-  flags?: string;
-};
-
-/**
- * And clause.
- *
- * @example
- * ```ts
- * {
- *   and: [...],
- * }
- * ```
- */
-export interface AndClause<M extends object = ModelData> {
-  and: WhereClause<M>[];
-}
-
-/**
- * Or clause.
- *
- * @example
- * ```ts
- * {
- *   or: [...],
- * }
- * ```
- */
-export interface OrClause<M extends object = ModelData> {
-  or: WhereClause<M>[];
-}
-
-/**
- * Order clause item.
- *
- * @example
- * ```ts
- * 'prop'
- * 'prop ASC'
- * 'prop DESC';
- * ```
- */
-export declare type OrderClauseItem<M extends object = ModelData> = {
-  [prop in keyof M]: prop | `${prop & string} ASC` | `${prop & string} DESC`;
-}[keyof M];
-
-/**
- * Order clause.
- *
- * @example
- * ```ts
- * 'prop'
- * 'prop ASC'
- * 'prop DESC';
- * ['prop1', 'prop2'];
- * ['prop1 ASC', 'prop2 DESC'];
- * ```
- */
-export declare type OrderClause<M extends object = ModelData> =
-  | OrderClauseItem<M>
-  | OrderClauseItem<M>[];
-
-/**
- * Fields.
- *
- * @example
- * ```ts
- * 'prop'
- * ['prop1', 'prop2']
- * ```
- */
-export declare type FieldsClause<M extends object = ModelData> =
-  | keyof M
-  | NormalizedFieldsClause<M>;
-
-/**
- * Normalized fields clause.
- *
- * @example
- * ```ts
- * [
- *   'prop1',
- *   'prop2',
- * ]
- * ```
- */
-export declare type NormalizedFieldsClause<M extends object = ModelData> =
-  (keyof M)[];
-
-/**
- * Include clause.
- *
- * @example
- * ```ts
- * 'customers'
- * ```
- *
- * @example
- * ```ts
- * [
- *   'customers',
- *   'orders',
- * ]
- * ```
- *
- * @example
- * ```ts
- * {
- *   customer: 'orders'
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   customer: {
- *     address: 'city',
- *   },
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   customer: [
- *     'orders',
- *     {address: 'city'},
- *   ],
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   relation: 'customer',
- *   scope: {
- *     where: {removed: false},
- *     order: 'createdAt DESC',
- *     skip: 0,
- *     limit: 16,
- *     fields: ['id', 'name', 'removed'],
- *     include: 'address',
- *   }
- * }
- * ```
- */
-export declare type IncludeClause<M extends object = ModelData> =
-  | keyof M
-  | (keyof M)[]
-  | NestedIncludeClause<M>
-  | NormalizedIncludeClause<M>
-  | IncludeClause[];
-
-/**
- * Nested include clause.
- *
- * @example
- * ```ts
- * {
- *   customer: 'orders'
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   customer: {
- *     address: 'city',
- *   },
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   customer: [
- *     'orders',
- *     {address: 'city'},
- *   ],
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   relation: 'customer',
- *   scope: {
- *     where: {removed: false},
- *     order: 'createdAt DESC',
- *     skip: 0,
- *     limit: 16,
- *     fields: ['id', 'name', 'removed'],
- *     include: 'address',
- *   }
- * }
- * ```
- */
-export declare type NestedIncludeClause<M extends object = ModelData> = {
-  [property in keyof M]?: IncludeClause;
-};
-
-/**
- * Inclusion.
- *
- * @example
- * ```ts
- * {
- *   relation: 'customer',
- * }
- * ```
- *
- * @example
- * ```ts
- * {
- *   relation: 'customer',
- *   scope: {
- *     where: {removed: false},
- *     order: 'createdAt DESC',
- *     skip: 0,
- *     limit: 16,
- *     fields: ['id', 'name', 'removed'],
- *     include: 'address',
- *   }
- * }
- * ```
- */
-export declare interface NormalizedIncludeClause<M extends object = ModelData> {
-  relation: keyof M;
-  scope?: FilterClause;
-}

package/src/filter/include-clause-tool.d.ts

@@ -1,55 +0,0 @@
-import {ModelData} from '../types.js';
-import {Service} from '@e22m4u/js-service';
-import {FilterClause} from './filter-clause.js';
-import {IncludeClause} from './filter-clause.js';
-import {NormalizedIncludeClause} from './filter-clause.js';
-
-/**
- * Include clause tool.
- */
-export declare class IncludeClauseTool extends Service {
-  /**
-   * Include to.
-   *
-   * @param entities
-   * @param modelName
-   * @param clause
-   */
-  includeTo(
-    entities: ModelData[],
-    modelName: string,
-    clause: IncludeClause | undefined,
-  ): Promise<void>;
-
-  /**
-   * Validate include clause.
-   *
-   * @param clause
-   */
-  static validateIncludeClause(clause: IncludeClause | undefined): void;
-
-  /**
-   * Validate scope clause.
-   *
-   * @param clause
-   */
-  static validateScopeClause(clause: FilterClause | undefined): void;
-
-  /**
-   * Normalize include clause.
-   *
-   * @param clause
-   */
-  static normalizeIncludeClause(
-    clause: IncludeClause | undefined,
-  ): NormalizedIncludeClause[];
-
-  /**
-   * Normalize scope clause.
-   *
-   * @param clause
-   */
-  static normalizeScopeClause(
-    clause: FilterClause | undefined,
-  ): FilterClause | undefined;
-}

package/src/filter/index.d.ts

@@ -1,7 +0,0 @@
-export * from './filter-clause.js';
-export * from './slice-clause-tool.js';
-export * from './order-clause-tool.js';
-export * from './where-clause-tool.js';
-export * from './fields-clause-tool.js';
-export * from './include-clause-tool.js';
-export * from './operator-clause-tool.js';

package/src/filter/operator-clause-tool.d.ts

@@ -1,224 +0,0 @@
-import {Service} from '@e22m4u/js-service';
-
-/**
- * Operator clause tool.
- */
-export declare class OperatorClauseTool extends Service {
-  /**
-   * Compare.
-   *
-   * @param val1
-   * @param val2
-   * @param noTypeConversion
-   */
-  compare(val1: unknown, val2: unknown, noTypeConversion?: boolean): number;
-
-  /**
-   * Test all operators.
-   *
-   * @param clause
-   * @param value
-   */
-  testAll(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test eq/neq operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   eq: 'foo',
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * {
-   *   neq: 'foo',
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testEqNeq(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test lt/gt/lte/gte operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   lt: 10,
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * {
-   *   lte: 10,
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * {
-   *   gt: 10,
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * {
-   *   gte: 10,
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testGtLt(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test inc operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   inc: ['foo', 'bar'],
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testInq(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test nin operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   nin: ['foo', 'bar'],
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testNin(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test between operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   between: [10, 20],
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testBetween(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test exists operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   exists: true,
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testExists(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test like operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   like: 'foo',
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testLike(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test nlike operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   nlike: 'foo',
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testNlike(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test ilike operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   ilike: 'foo',
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testIlike(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test nilike operator.
-   *
-   * @example
-   * ```ts
-   * {
-   *   nilike: 'foo',
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testNilike(clause: object, value: unknown): boolean | undefined;
-
-  /**
-   * Test regexp.
-   *
-   * @example
-   * ```ts
-   * {
-   *   regexp: 'foo.*',
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * {
-   *   regexp: 'foo.*',
-   *   flags: 'i',
-   * }
-   * ```
-   *
-   * @param clause
-   * @param value
-   */
-  testRegexp(clause: object, value: unknown): boolean | undefined;
-}

package/src/filter/order-clause-tool.d.ts

@@ -1,32 +0,0 @@
-import {ModelData} from '../types.js';
-import {Service} from '@e22m4u/js-service';
-import {OrderClause} from './filter-clause.js';
-
-/**
- * Order clause tool.
- */
-export declare class OrderClauseTool extends Service {
-  /**
-   * Sort.
-   *
-   * @param entities
-   * @param clause
-   */
-  sort(entities: ModelData[], clause: OrderClause | undefined): void;
-
-  /**
-   * Validate order clause.
-   *
-   * @param clause
-   */
-  static validateOrderClause(clause: OrderClause | undefined): void;
-
-  /**
-   * Normalize order clause.
-   *
-   * @param clause
-   */
-  static normalizeOrderClause(
-    clause: OrderClause | undefined,
-  ): string[] | undefined;
-}

package/src/filter/slice-clause-tool.d.ts

@@ -1,30 +0,0 @@
-import {ModelData} from '../types.js';
-import {Service} from '@e22m4u/js-service';
-
-/**
- * Slice clause tool.
- */
-export declare class SliceClauseTool extends Service {
-  /**
-   * Slice.
-   *
-   * @param entities
-   * @param skip
-   * @param limit
-   */
-  slice(entities: ModelData[], skip?: number, limit?: number): ModelData[];
-
-  /**
-   * Validate skip clause.
-   *
-   * @param skip
-   */
-  static validateSkipClause(skip: number | undefined): void;
-
-  /**
-   * Validate limit clause.
-   *
-   * @param limit
-   */
-  static validateLimitClause(limit: number | undefined): void;
-}

package/src/filter/where-clause-tool.d.ts

@@ -1,23 +0,0 @@
-import {ModelData} from '../types.js';
-import {Service} from '@e22m4u/js-service';
-import {WhereClause} from './filter-clause.js';
-
-/**
- * Where clause tool.
- */
-export declare class WhereClauseTool extends Service {
-  /**
-   * Filter.
-   *
-   * @param entities
-   * @param where
-   */
-  filter(entities: ModelData[], where: WhereClause | undefined): ModelData[];
-
-  /**
-   * Validate where clause.
-   *
-   * @param clause
-   */
-  static validateWhereClause(clause: WhereClause | undefined): void;
-}

package/src/index.d.ts

@@ -1,9 +0,0 @@
-export * from './types.js';
-export * from './utils/index.js';
-export * from './errors/index.js';
-export * from './filter/index.js';
-export * from './adapter/index.js';
-export * from './database-schema.js';
-export * from './relations/index.js';
-export * from './definition/index.js';
-export * from './repository/index.js';