@decaf-ts/core 0.3.37 → 0.3.38

package/lib/query/options.d.ts

@@ -1,372 +0,0 @@
-import { GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
-import { Executor } from "../interfaces";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { Condition } from "./Condition";
-import { Paginatable } from "../interfaces/Paginatable";
-/**
- * @summary Statement Builder interface
- * @description Exposes the final method to build the statement
- *
- * @typedef Q The query object type to build
- * @interface QueryBuilder
- *
- * @category Query
- * @subcategory Options
- *
- */
-export interface QueryBuilder<Q> extends Executor {
-    /**
-     * Method to build and validate the prepared statement before the execution;
-     *
-     * @throws {QueryError}  for invalid statements
-     * @method
-     */
-    build(previous: Q): Q;
-}
-/**
- * @summary GroupBy Option interface
- * @description Exposes the GROUP BY method and remaining options
- *
- * @interface GroupByOption
- * @extends QueryBuilder
- *
- * @category Query
- * @subcategory Options
- */
-export interface GroupByOption extends Executor {
-    /**
-     * @summary Groups records by an attribute
-     *
-     * @param {GroupBySelector} selector
-     * @method
-     */
-    groupBy(selector: GroupBySelector): Executor;
-}
-/**
- * @summary Offset Option interface
- * @description Exposes the OFFSET method and remaining options
- *
- * @interface GroupByOption
- * @extends QueryBuilder
- *
- * @category Query
- * @subcategory Options
- */
-export interface OffsetOption extends Executor {
-    /**
-     * @summary Offsets the results by the provided selector
-     *
-     * @param {OffsetSelector} selector
-     * @method
-     */
-    offset(selector: OffsetSelector): Executor;
-}
-/**
- * @summary Limit Option interface
- * @description Exposes the LIMIT method and remaining options
- *
- * @interface LimitOption
- * @extends QueryBuilder
- *
- * @category Query
- * @subcategory Options
- */
-export interface LimitOption extends Executor, Paginatable {
-    /**
-     * @summary Limits the results to the provided number
-     *
-     * @param {LimitSelector} selector
-     * @method
-     */
-    limit(selector: LimitSelector): OffsetOption;
-}
-/**
- * @summary OrderpBy Option interface
- * @description Exposes the ORDER BY method and remaining options
- *
- * @interface OrderByOption
- * @extends QueryBuilder
- *
- * @category Query
- * @subcategory Options
- */
-export interface OrderByOption extends Executor, Paginatable {
-    /**
-     * @summary Orders the results by the provided attribute and according to the provided direction
-     *
-     * @param {OrderBySelector} selector
-     * @method
-     */
-    orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption;
-}
-/**
- * @summary Groups several order and grouping options
- *
- * @interface OrderAndGroupOption
- * @extends OrderByOption
- * @extends GroupByOption
- * @extends LimitOption
- * @extends OffsetOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface OrderAndGroupOption extends OrderByOption, GroupByOption, LimitOption, OffsetOption {
-}
-/**
- * @summary Where Option interface
- * @description Exposes the WHERE method and remaining options
- *
- * @interface WhereOption
- * @extends OrderAndGroupOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface WhereOption extends OrderAndGroupOption {
-    /**
-     * @summary filter the records by a condition
-     *
-     * @param {Condition} condition
-     * @method
-     */
-    where(condition: Condition): OrderAndGroupOption;
-}
-/**
- * @summary From Option Interface
- * @description Exposes the FROM method and remaining options
- *
- * @interface FromOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface FromOption<M extends Model> {
-    /**
-     * @summary selects records from a table
-     *
-     * @param {Constructor} tableName
-     * @method
-     */
-    from(tableName: Constructor<M> | string): WhereOption;
-}
-/**
- * @summary Distinct Option Interface
- * @description Exposes the remaining options after a DISTINCT
- *
- * @interface DistinctOption
- * @extends FromOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface DistinctOption<M extends Model> extends FromOption<M> {
-}
-/**
- * @summary Max Option Interface
- * @description Exposes the remaining options after a MAX
- *
- * @interface MaxOption
- * @extends FromOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface MaxOption<M extends Model> extends FromOption<M> {
-}
-/**
- * @summary Min Option Interface
- * @description Exposes the remaining options after a MIN
- *
- * @interface MinOption
- * @extends FromOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface MinOption<M extends Model> extends FromOption<M> {
-}
-/**
- * @summary Count Option Interface
- * @description Exposes the remaining options after a COUNT
- *
- * @interface CountOption
- * @extends FromOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface CountOption<M extends Model> extends FromOption<M> {
-}
-/**
- * @summary Select Option Interface
- * @description Exposes the remaining options after a SELECT
- *
- * @interface SelectOption
- * @extends FromOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface SelectOption<M extends Model> extends FromOption<M> {
-    /**
-     * @summary selects distinct values
-     *
-     * @param {SelectSelector} selector
-     * @method
-     */
-    distinct(selector: SelectSelector): DistinctOption<M>;
-    /**
-     * @summary the maximum value
-     *
-     * @param {SelectSelector} selector
-     * @method
-     */
-    max(selector: SelectSelector): MaxOption<M>;
-    /**
-     * @summary selects the minimum value
-     *
-     * @param {SelectSelector} selector
-     * @method
-     */
-    min(selector: SelectSelector): MinOption<M>;
-    /**
-     * @summary counts the records
-     *
-     * @param {SelectSelector} selector
-     * @method
-     */
-    count(selector?: SelectSelector): CountOption<M>;
-}
-/**
- * @summary Into Option Interface
- * @description Exposes the remaining options after an INTO
- *
- * @interface IntoOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface IntoOption<M extends Model> {
-    /**
-     * @summary sets the models to insert
-     *
-     * @param {T[]} models
-     * @method
-     */
-    values(...models: M[]): Executor;
-    /**
-     * @summary filter records to insert
-     *
-     * @param {Condition} condition
-     * @method
-     */
-    where(condition: Condition): Executor;
-}
-/**
- * @summary Valuest Option Interface
- * @description Exposes the remaining options after a VALUES
- *
- * @interface ValuesOption
- * @extends QueryBuilder
- *
- * @category Query
- * @subcategory Options
- */
-export interface ValuesOption extends Executor {
-}
-/**
- * @summary Insert Option Interface
- * @description Exposes the remaining options after an INSERT
- *
- * @interface InsertOption
- *
- * @category Query
- * @subcategory Options
- */
-export interface InsertOption<M extends Model> {
-    /**
-     * @summary selects the table to insert records into
-     *
-     * @param {string | Constructor} table
-     * @method
-     */
-    into(table: Constructor<M>): IntoOption<M>;
-}
-/**
- * @summary {@link Operator} Option Interface
- * @description Exposes the available operators for a {@link Condition}
- *
- * @interface AttributeOption
- *
- * @category Query
- * @subcategory Conditions
- */
-export interface AttributeOption {
-    /**
-     * @summary Test equality
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    eq(val: any): Condition;
-    /**
-     * @summary Test difference
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    dif(val: any): Condition;
-    /**
-     * @summary Test greater than
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    gt(val: any): Condition;
-    /**
-     * @summary Test lower than
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    lt(val: any): Condition;
-    /**
-     * @summary Test greater or equal to
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    gte(val: any): Condition;
-    /**
-     * @summary Test lower or equal to
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    lte(val: any): Condition;
-    /**
-     * @summary Test value in a range of values
-     * @param {any[]} val
-     */
-    in(val: any[]): Condition;
-    /**
-     * @summary Test matches {@link RegExp}
-     *
-     * @param {any} val the value to test
-     * @method
-     */
-    regexp(val: string | RegExp): Condition;
-}
-/**
- * @summary The starting point for creating Conditions
- * @description Exposes the available operations for a {@link Condition}
- *
- * @interface ConditionBuilderOption
- *
- * @category Query
- * @subcategory Conditions
- */
-export interface ConditionBuilderOption {
-    attribute(attr: string): AttributeOption;
-}

package/lib/query/selectors.d.ts

@@ -1,38 +0,0 @@
-import { OrderDirection } from "../repository";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-/**
- * @typedef FromSelector
- *
- * @category Clauses
- */
-export type FromSelector<M extends Model> = Constructor<M> | string;
-/**
- * @typedef GroupBySelector
- *
- * @category Clauses
- */
-export type GroupBySelector = string;
-/**
- * @typedef OrderBySelector
- *
- * @category Clauses
- */
-export type OrderBySelector = [string, OrderDirection];
-/**
- * @typedef LimitSelector
- *
- * @category Clauses
- */
-export type LimitSelector = number;
-/**
- * @typedef OffsetSelector
- *
- * @category Clauses
- */
-export type OffsetSelector = number;
-/**
- * @typedef SelectSelector
- *
- * @category Clauses
- */
-export type SelectSelector = string | string[];

package/lib/query/types.d.ts

@@ -1,2 +0,0 @@
-export type AttributeResult = Record<string, string>;
-export type OperationResult = Record<string, AttributeResult | any>;

package/lib/repository/Context.d.ts

@@ -1,10 +0,0 @@
-import { Context as Ctx } from "@decaf-ts/db-decorators";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { OperationKeys } from "@decaf-ts/db-decorators";
-import { User } from "../model";
-export declare abstract class Context<M extends Model, U extends User = User> extends Ctx<M> {
-    protected _timestamp: Date;
-    protected constructor(operation: OperationKeys, model?: Constructor<M>, parent?: Context<any, any>);
-    get timestamp(): Date;
-    abstract get user(): U | undefined;
-}

package/lib/repository/Repository.d.ts

@@ -1,70 +0,0 @@
-import { IRepository, Repository as Rep } from "@decaf-ts/db-decorators";
-import { Observable } from "../interfaces/Observable";
-import { Observer } from "../interfaces/Observer";
-import { Adapter } from "../persistence/Adapter";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { OrderDirection } from "./constants";
-import { SequenceOptions } from "../interfaces/SequenceOptions";
-import { Queriable } from "../interfaces/Queriable";
-import { IndexMetadata } from "./types";
-import { Condition } from "../query/Condition";
-import { WhereOption } from "../query/options";
-import { SelectSelector } from "../query/selectors";
-export type Repo<M extends Model, Q = any, A extends Adapter<any, Q> = Adapter<any, Q>> = Repository<M, Q, A>;
-export declare class Repository<M extends Model, Q, A extends Adapter<any, Q>> extends Rep<M> implements Observable, Queriable, IRepository<M> {
-    private static _cache;
-    protected observers: Observer[];
-    private readonly _adapter;
-    private _tableName;
-    protected get adapter(): A;
-    protected get tableName(): string;
-    constructor(adapter?: A, clazz?: Constructor<M>);
-    protected createPrefix(model: M, ...args: any[]): Promise<[M, ...any[]]>;
-    create(model: M, ...args: any[]): Promise<M>;
-    createAll(models: M[], ...args: any[]): Promise<M[]>;
-    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
-    protected readPrefix(key: string, ...args: any[]): Promise<any[]>;
-    read(id: string | number | bigint, ...args: any[]): Promise<M>;
-    protected readAllPrefix(keys: string[] | number[], ...args: any[]): Promise<any[]>;
-    readAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
-    update(model: M, ...args: any[]): Promise<M>;
-    protected updatePrefix(model: M, ...args: any[]): Promise<[M, ...args: any[]]>;
-    updateAll(models: M[], ...args: any[]): Promise<M[]>;
-    protected updateAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
-    protected deletePrefix(key: any, ...args: any[]): Promise<any[]>;
-    delete(id: string | number | bigint, ...args: any[]): Promise<M>;
-    protected deleteAllPrefix(keys: string[] | number[], ...args: any[]): Promise<any[]>;
-    deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
-    select(selector?: SelectSelector): WhereOption;
-    query<V>(condition: Condition, orderBy: string, order?: OrderDirection, limit?: number, skip?: number): Promise<V>;
-    /**
-     * @summary Registers an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#observe}
-     */
-    observe(observer: Observer): void;
-    /**
-     * @summary Unregisters an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#unObserve}
-     */
-    unObserve(observer: Observer): void;
-    /**
-     * @summary calls all registered {@link Observer}s to update themselves
-     * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
-     */
-    updateObservers(...args: any[]): Promise<void>;
-    static forModel<M extends Model, R extends Repo<M>>(model: Constructor<M>, defaultFlavour?: string): R;
-    private static get;
-    static register<M extends Model>(model: Constructor<M>, repo: Constructor<Repo<M>> | Repo<M>): void;
-    static setMetadata<M extends Model>(model: M, metadata: any): void;
-    static getMetadata<M extends Model>(model: M): any;
-    static removeMetadata<M extends Model>(model: M): void;
-    static getSequenceOptions<M extends Model>(model: M): SequenceOptions;
-    static indexes<M extends Model>(model: M | Constructor<M>): Record<string, Record<string, IndexMetadata>>;
-    static relations<M extends Model>(model: M | Constructor<M>): string[];
-    static table<M extends Model>(model: M | Constructor<M>): any;
-    static column<M extends Model>(model: M, attribute: string): any;
-}

package/lib/repository/constants.d.ts

@@ -1,25 +0,0 @@
-import { CascadeMetadata } from "./types";
-/**
- * @summary defines order directions when sorting
- *
- * @constant OrderDirection
- *
- * @category Query
- */
-export declare enum OrderDirection {
-    /**
-     * @summary Defines the sort order as ascending
-     * @prop ASC
-     */
-    ASC = "asc",
-    /**
-     * @summary Defines the sort order as descending
-     * @property {string} DSC
-     */
-    DSC = "desc"
-}
-export declare enum Cascade {
-    CASCADE = "cascade",
-    NONE = "none"
-}
-export declare const DefaultCascade: CascadeMetadata;

package/lib/repository/decorators.d.ts

@@ -1,2 +0,0 @@
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-export declare function repository<T extends Model>(model: Constructor<T>, nameOverride?: string): any;

package/lib/repository/errors.d.ts

@@ -1,12 +0,0 @@
-import { BaseError } from "@decaf-ts/db-decorators";
-/**
- * @summary Represents a failure in observer communication
- *
- * @param {string} msg the error message
- *
- * @class ObserverError
- * @extends BaseError
- */
-export declare class ObserverError extends BaseError {
-    constructor(msg: string | Error);
-}

package/lib/repository/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./constants";
-export * from "./Context";
-export * from "./decorators";
-export * from "./errors";
-export * from "./injectables";
-export * from "./Repository";
-export * from "./types";
-export * from "./utils";

package/lib/repository/injectables.d.ts

@@ -1,5 +0,0 @@
-import { InjectableRegistryImp } from "@decaf-ts/injectable-decorators";
-export declare class InjectablesRegistry extends InjectableRegistryImp {
-    constructor();
-    get<T>(name: string): T | undefined;
-}

package/lib/repository/types.d.ts

@@ -1,15 +0,0 @@
-import { Cascade, OrderDirection } from "./constants";
-/**
- * @summary defines the cascading behaviour
- */
-export type CascadeMetadata = {
-    update: Cascade;
-    delete: Cascade;
-};
-export type IndexMetadata = {
-    directions?: OrderDirection[2];
-    compositions?: string[];
-};
-export type NamedIndexMetadata = IndexMetadata & {
-    suffix: string;
-};

package/lib/repository/utils.d.ts

@@ -1,3 +0,0 @@
-import { Constructor } from "@decaf-ts/decorator-validation";
-import { Model } from "@decaf-ts/decorator-validation";
-export declare function generateInjectableNameForRepository<T extends Model>(model: Constructor<T> | T, flavour?: string): string;

package/lib/validators/ClauseSequenceValidator.d.ts

@@ -1,28 +0,0 @@
-import { Validator } from "@decaf-ts/decorator-validation";
-/**
- * @summary Validates a {@link Sequence}'s {@link Clause}s
- *
- * @param {string} [message]
- *
- * @class ClauseSequenceValidator
- * @extends Validator
- *
- * @category Validation
- * @subcategory Validators
- */
-export declare class ClauseSequenceValidator extends Validator {
-    constructor(message?: string);
-    private validateSequence;
-    /**
-     * @summary Verifies the model for errors
-     * @param {string} value
-     * @param {string} [message]
-     *
-     * @return Errors
-     *
-     * @override
-     *
-     * @see Validator
-     */
-    hasErrors(value: any, message?: string): string | undefined;
-}

package/lib/validators/decorators.d.ts

@@ -1,10 +0,0 @@
-/**
- *
- * @param {string} [message]
- *
- * @function clauseSequence
- *
- * @category Decorators
- * @subcategory Validation
- */
-export declare function clauseSequence(message?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/validators/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./decorators";
-export * from "./ClauseSequenceValidator";