@decaf-ts/core 0.3.37 → 0.3.38

package/lib/interfaces/Builder.d.ts

@@ -1,16 +0,0 @@
-/**
- * @summary Standard Builder APi for the Builder design pattern
- * @description Expose the build method
- *
- * @interface Builder
- *
- * @category Construction
- */
-export interface Builder<T> {
-    /**
-     * @summary Build the Object
-     *
-     * @method
-     */
-    build(...args: any[]): T;
-}

package/lib/interfaces/Executor.d.ts

@@ -1,19 +0,0 @@
-/**
- * @summary processes query objects
- *
- * @typedef V the output
- *
- * @interface Executor
- *
- * @category Query
- */
-export interface Executor {
-    /**
-     * @summary Processes itself
-     *
-     * @param {any[]} args
-     *
-     * @method
-     */
-    execute<V>(...args: any): Promise<V>;
-}

package/lib/interfaces/Observable.d.ts

@@ -1,31 +0,0 @@
-import { Observer } from "./Observer";
-/**
- * @summary Observable Api
- * @description manage and update {@link Observer}s
- *
- * @interface Observable
- *
- * @category Observables
- */
-export interface Observable {
-    /**
-     * @summary Register new {@link Observer}s
-     * @param {Observer} observer
-     *
-     * @method
-     */
-    observe(observer: Observer): void;
-    /**
-     * @summary Unregister new {@link Observer}s
-     * @param {Observer} observer
-     *
-     * @method
-     */
-    unObserve(observer: Observer): void;
-    /**
-     * @summary have registered {@link Observer}s update themselves
-     * @param {any[]} args
-     * @method
-     */
-    updateObservers(...args: any[]): Promise<void>;
-}

package/lib/interfaces/Observer.d.ts

@@ -1,16 +0,0 @@
-/**
- * @summary Observer Api
- * @description will be called by the {@link Observable}
- *
- * @interface Observer
- *
- * @category Observables
- */
-export interface Observer {
-    /**
-     * @summary Refreshes the Observer
-     * @param {any[]} args
-     * @method
-     */
-    refresh(...args: any[]): Promise<void>;
-}

package/lib/interfaces/Paginatable.d.ts

@@ -1,4 +0,0 @@
-import { Paginator } from "../query/Paginator";
-export interface Paginatable {
-    paginate<V>(...args: any[]): Promise<Paginator<V, any>>;
-}

package/lib/interfaces/Queriable.d.ts

@@ -1,6 +0,0 @@
-import { Condition, SelectSelector, WhereOption } from "../query";
-import { OrderDirection } from "../repository";
-export interface Queriable {
-    select(selector?: SelectSelector): WhereOption;
-    query<V>(condition: Condition, orderBy: string, order: OrderDirection, limit?: number, skip?: number): Promise<V>;
-}

package/lib/interfaces/RawExecutor.d.ts

@@ -1,20 +0,0 @@
-/**
- * @summary Executes a raw instruction in the Database
- * @typeDef Q The input type
- * @typeDef R The result type
- *
- * @interface RawExecutor
- * @category Query
- */
-export interface RawExecutor<Q> {
-    /**
-     * @summary Executes a raw instruction in the Database
-     *
-     * @typeDef V the expected outcome of the instruction
-     * @param rawInput
-     * @param args
-     *
-     * @method
-     */
-    raw<R>(rawInput: Q, ...args: any[]): Promise<R>;
-}

package/lib/interfaces/SequenceOptions.d.ts

@@ -1,19 +0,0 @@
-/**
- * @typedef SequenceOptions
- *
- * @prop {string | number} [startingValue] defines the starting value when sequence doest not exist
- *
- * @category Sequences
- */
-export interface SequenceOptions {
-    name?: string;
-    type: "Number" | "BigInt" | undefined;
-    startWith: number;
-    incrementBy: number;
-    minValue?: number;
-    maxValue?: number;
-    cycle: boolean;
-}
-export declare const DefaultSequenceOptions: SequenceOptions;
-export declare const NumericSequence: SequenceOptions;
-export declare const BigIntSequence: SequenceOptions;

package/lib/interfaces/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./Builder";
-export * from "./Executor";
-export * from "./Observable";
-export * from "./Observer";
-export * from "./Queriable";
-export * from "./RawExecutor";
-export * from "./SequenceOptions";

package/lib/model/BaseModel.d.ts

@@ -1,6 +0,0 @@
-import { ModelArg, Model } from "@decaf-ts/decorator-validation";
-export declare abstract class BaseModel extends Model {
-    createdOn: Date;
-    updatedOn: Date;
-    protected constructor(arg?: ModelArg<BaseModel>);
-}

package/lib/model/IdentifiedBaseModel.d.ts

@@ -1,7 +0,0 @@
-import { ModelArg } from "@decaf-ts/decorator-validation";
-import { BaseModel } from "./BaseModel";
-export declare abstract class IdentifiedBaseModel extends BaseModel {
-    createdBy: string;
-    updatedBy: string;
-    protected constructor(arg?: ModelArg<IdentifiedBaseModel>);
-}

package/lib/model/User.d.ts

@@ -1,8 +0,0 @@
-import { Model, ModelArg } from "@decaf-ts/decorator-validation";
-import { Roles } from "../persistence/constants";
-export declare class User extends Model {
-    id: string;
-    roles?: (string | Roles)[];
-    affiliations?: string[];
-    constructor(arg?: ModelArg<User>);
-}

package/lib/model/decorators.d.ts

@@ -1,75 +0,0 @@
-import { CascadeMetadata } from "../repository/types";
-import { OrderDirection } from "../repository/constants";
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { Repo } from "../repository/Repository";
-import { Context } from "../repository/Context";
-export declare function table(tableName: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function column(columnName: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-/**
- * @summary Index Decorator
- * @description properties decorated will the index in the
- * DB for performance in queries
- *
- * @param {OrderDirection[]} [directions]
- * @param {string[]} [compositions]
- *
- * @function index
- */
-export declare function index(directions?: OrderDirection[], compositions?: string[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function uniqueOnCreateUpdate<M extends Model, R extends Repo<M>, Y = any>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
-/**
- * @summary Unique Decorator
- * @description Tags a property as unique.
- *  No other elements in that table can have the same property value
- *
- * @function unique
- *
- * @memberOf module:wallet-db.Decorators
- */
-export declare function unique(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function createdByOnCreateUpdate<M extends Model, R extends Repo<M>, Y = any>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void>;
-export declare function createdBy(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function updatedBy(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-/**
- * @summary One To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database
- *
- * @function onToOne
- *
- * @memberOf module:wallet-db.Decorators
- *
- * @see oneToMany
- * @see manyToOne
- */
-export declare function oneToOne<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-/**
- * @summary One To Many relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
- * @function oneToMany
- *
- * @memberOf module:wallet-db.Decorators
- *
- * @see oneToOne
- * @see manyToOne
- */
-export declare function oneToMany<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-/**
- * @summary Many To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
- * @function manyToOne
- *
- * @memberOf module:wallet-db.Decorators
- *
- * @see oneToMany
- * @see oneToOne
- */
-export declare function manyToOne(clazz: Constructor<any>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/model/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./BaseModel";
-export * from "./decorators";
-export * from "./types";
-export * from "./User";

package/lib/model/types.d.ts

@@ -1,6 +0,0 @@
-import { CascadeMetadata } from "../repository";
-export type RelationsMetadata = {
-    class: string;
-    cascade: CascadeMetadata;
-    populate: boolean;
-};

package/lib/persistence/Adapter.d.ts

@@ -1,86 +0,0 @@
-import { BaseError, Context, OperationKeys } from "@decaf-ts/db-decorators";
-import { Observer } from "../interfaces/Observer";
-import { Constructor, Model, ModelConstructor } from "@decaf-ts/decorator-validation";
-import { SequenceOptions } from "../interfaces/SequenceOptions";
-import { RawExecutor } from "../interfaces/RawExecutor";
-import { Observable } from "../interfaces/Observable";
-import { Query } from "../query/Query";
-import { Statement } from "../query/Statement";
-import { ClauseFactory } from "../query/ClauseFactory";
-import { Condition } from "../query/Condition";
-import { Repository } from "../repository/Repository";
-import { Sequence } from "./Sequence";
-import { User } from "../model/User";
-/**
- * @summary Abstract Decaf-ts Persistence Adapter Class
- * @description Offers the base implementation for all Adapter Classes
- * and manages them various registered {@link Adapter}s
- *
- * @typedef Y the underlying persistence object type
- * @typedef Q The query object the adapter uses
- *
- * @param {Y} native the underlying persistence object
- * @param {string} flavour the under witch the persistence adapter should be stored
- *
- * @class Adapter
- * @implements RawExecutor
- * @implements Observable
- */
-export declare abstract class Adapter<Y, Q> implements RawExecutor<Q>, Observable {
-    readonly flavour: string;
-    private static _current;
-    private static _cache;
-    protected readonly _observers: Observer[];
-    private readonly _native;
-    get native(): Y;
-    repository<M extends Model>(): Constructor<Repository<M, Q, Adapter<Y, Q>>>;
-    protected constructor(native: Y, flavour: string);
-    Query<M extends Model>(): Query<Q, M>;
-    abstract parseCondition(condition: Condition): Q;
-    abstract get Statement(): Statement<Q>;
-    abstract get Clauses(): ClauseFactory<Y, Q>;
-    protected isReserved(attr: string): boolean;
-    protected abstract parseError(err: Error): BaseError;
-    abstract initialize(...args: any[]): Promise<void>;
-    abstract Sequence(options: SequenceOptions): Promise<Sequence>;
-    protected abstract user(): Promise<User | undefined>;
-    context<M extends Model, C extends Context<M>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>): Promise<C>;
-    prepare<M extends Model>(model: M, pk: string | number): {
-        record: Record<string, any>;
-        id: string;
-    };
-    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: string, id: string | number | bigint): M;
-    abstract create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
-    createAll(tableName: string, id: (string | number)[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
-    abstract read(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
-    readAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
-    abstract update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
-    updateAll(tableName: string, id: string[] | number[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
-    abstract delete(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
-    deleteAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
-    abstract raw<R>(rawInput: Q, process: boolean, ...args: any[]): Promise<R>;
-    /**
-     * @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 get current(): Adapter<any, any>;
-    static get<Y, Q>(flavour: any): Adapter<Y, Q> | undefined;
-    static setCurrent(flavour: string): void;
-    static key(key: string): string;
-    static models<M extends Model>(flavour: string): ModelConstructor<any>[];
-}

package/lib/persistence/Sequence.d.ts

@@ -1,22 +0,0 @@
-/**
- * @summary Sequence
- *
- * @interface Sequence
- *
- * @category Sequences
- */
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { SequenceOptions } from "../interfaces/SequenceOptions";
-export declare abstract class Sequence {
-    protected readonly options: SequenceOptions;
-    protected constructor(options: SequenceOptions);
-    /**
-     * @summary generates the next value in the sequence
-     *
-     * @method
-     */
-    abstract next(): Promise<string | number | bigint>;
-    abstract current(): Promise<string | number | bigint>;
-    abstract range(count: number): Promise<(number | string | bigint)[]>;
-    static pk<M extends Model>(model: M | Constructor<M>): string;
-}

package/lib/persistence/constants.d.ts

@@ -1,22 +0,0 @@
-export declare enum PersistenceKeys {
-    INDEX = "index",
-    UNIQUE = "unique",
-    ADAPTER = "adapter",
-    INJECTABLE = "decaf_{0}_adapter_for_{1}",
-    TABLE = "table",
-    COLUMN = "column",
-    METADATA = "__metadata",
-    RELATIONS = "__relations",
-    CLAUSE_SEQUENCE = "clause-sequence",
-    CREATED_BY = "ownership.created-by",
-    UPDATED_BY = "ownership.updated-by",
-    ONE_TO_ONE = "relations.one-to-one",
-    ONE_TO_MANY = "relations.one-to-many",
-    MANY_TO_ONE = "relations.many-to-one",
-    POPULATE = "populate"
-}
-export declare enum Roles {
-    ADMIN = "admin",
-    WRITER = "writer",
-    READER = "reader"
-}

package/lib/persistence/decorators.d.ts

@@ -1 +0,0 @@
-export declare function uses(flavour: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/persistence/errors.d.ts

@@ -1,7 +0,0 @@
-import { BaseError } from "@decaf-ts/db-decorators";
-export declare class ConnectionError extends BaseError {
-    constructor(msg: string | Error);
-}
-export declare class UnsupportedError extends BaseError {
-    constructor(msg: string | Error);
-}

package/lib/persistence/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./Adapter";
-export * from "./constants";
-export * from "./decorators";
-export * from "./errors";
-export * from "./Sequence";

package/lib/query/Clause.d.ts

@@ -1,50 +0,0 @@
-import { Executor } from "../interfaces";
-import { Model, ModelArg } from "@decaf-ts/decorator-validation";
-import { QueryBuilder } from "./options";
-import { Priority } from "./constants";
-import { Statement } from "./Statement";
-import { Paginatable } from "../interfaces/Paginatable";
-import { Paginator } from "./Paginator";
-/**
- */
-/**
- * @summary Clause Class
- * @description Represents a Clause in a {@link Statement}
- *
- * @typedef Q Represents que query object the persistence adapter uses
- *
- * @param {ModelArg<Clause<Q>>} [clause]
- *
- * @class Clause
- * @extends Model
- * @implements Executor
- * @implements QueryBuilder
- * @abstract
- *
- * @category Query
- * @subcategory Clauses
- */
-export declare abstract class Clause<Q> extends Model implements Executor, Paginatable, QueryBuilder<Q> {
-    readonly priority: Priority;
-    readonly statement: Statement<Q>;
-    protected constructor(clause?: ModelArg<Clause<Q>>);
-    protected get adapter(): import("..").Adapter<any, Q>;
-    protected get Clauses(): import("./ClauseFactory").ClauseFactory<any, Q>;
-    /**
-     * @summary return the priority of the clause
-     * @see Priority
-     */
-    getPriority(): number;
-    abstract build(previous: Q): Q;
-    /**
-     * @inheritDoc
-     * @abstract
-     */
-    execute<R>(): Promise<R>;
-    /**
-     * @inheritDoc
-     * @abstract
-     */
-    paginate<R>(size: number): Promise<Paginator<R, Q>>;
-    toString(): string;
-}

package/lib/query/ClauseFactory.d.ts

@@ -1,71 +0,0 @@
-import { FromClause } from "./clauses";
-import { GroupByClause } from "./clauses/GroupByClause";
-import { InsertClause } from "./clauses/InsertClause";
-import { LimitClause } from "./clauses/LimitClause";
-import { OffsetClause } from "./clauses/OffsetClause";
-import { OrderByClause } from "./clauses/OrderByClause";
-import { SelectClause } from "./clauses/SelectClause";
-import { ValuesClause } from "./clauses/ValuesClause";
-import { WhereClause } from "./clauses/WhereClause";
-import { Adapter } from "../persistence";
-import { Condition } from "./Condition";
-import { FromSelector, GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
-import { Statement } from "./Statement";
-import { Model } from "@decaf-ts/decorator-validation";
-export declare abstract class ClauseFactory<Y, Q> {
-    protected adapter: Adapter<Y, Q>;
-    /**
-     * @summary Factory method for {@link FromClause}
-     * @param {Statement} statement
-     * @param {FromSelector} selector
-     */
-    abstract from<M extends Model>(statement: Statement<Q>, selector: FromSelector<M>): FromClause<Q, M>;
-    /**
-     * @summary Factory method for {@link GroupByClause}
-     * @param {Statement} statement
-     * @param {GroupBySelector} selector
-     */
-    abstract groupBy(statement: Statement<Q>, selector: GroupBySelector): GroupByClause<Q>;
-    /**
-     * @summary Factory method for {@link InsertClause}
-     * @param {Statement} statement
-     */
-    abstract insert<M extends Model>(): InsertClause<Q, M>;
-    /**
-     * @summary Factory method for {@link LimitClause}
-     * @param {Statement} statement
-     * @param {LimitSelector} selector
-     */
-    abstract limit(statement: Statement<Q>, selector: LimitSelector): LimitClause<Q>;
-    /**
-     * @summary Factory method for {@link OffsetClause}
-     * @param {Statement} statement
-     * @param {OffsetSelector} selector
-     */
-    abstract offset(statement: Statement<Q>, selector: OffsetSelector): OffsetClause<Q>;
-    /**
-     * @summary Factory method for {@link OrderByClause}
-     * @param {Statement} statement
-     * @param {OrderBySelector} selector
-     */
-    abstract orderBy(statement: Statement<Q>, selector: OrderBySelector[]): OrderByClause<Q>;
-    /**
-     * @summary Factory method for {@link SelectClause}
-     * @param {Statement} statement
-     * @param {SelectSelector} [selector]
-     */
-    abstract select<M extends Model>(selector?: SelectSelector): SelectClause<Q, M>;
-    /**
-     * @summary Factory method for {@link ValuesClause}
-     * @param {Statement} statement
-     * @param {M[]} values
-     */
-    abstract values<M extends Model>(statement: Statement<Q>, values: M[]): ValuesClause<Q, M>;
-    /**
-     * @summary Factory method for {@link WhereClause}
-     * @param {Statement} statement
-     * @param {Condition} condition
-     */
-    abstract where(statement: Statement<Q>, condition: Condition): WhereClause<Q>;
-    protected constructor(adapter: Adapter<Y, Q>);
-}

package/lib/query/Condition.d.ts

@@ -1,75 +0,0 @@
-import { AttributeOption, ConditionBuilderOption } from "./options";
-import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
-import { GroupOperator, Operator } from "./constants";
-/**
- * @summary Condition Class
- * @description Represents a logical condition
- *
- * @param {string | Condition} attr1
- * @param {Operator | GroupOperator} operator
- * @param {string | Condition} comparison
- *
- * @class Condition
- * @implements Executor
- *
- * @category Query
- * @subcategory Conditions
- */
-export declare class Condition extends Model {
-    protected attr1?: string | Condition;
-    protected operator?: Operator | GroupOperator;
-    protected comparison?: any;
-    private constructor();
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition
-     */
-    and(condition: Condition): Condition;
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition
-     */
-    or(condition: Condition): Condition;
-    /**
-     * @summary excludes a valut from the result
-     * @param val
-     */
-    not(val: any): Condition;
-    /**
-     * @inheritDoc
-     */
-    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
-     */
-    static and(condition1: Condition, condition2: Condition): Condition;
-    /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
-     */
-    static or(condition1: Condition, condition2: Condition): Condition;
-    /**
-     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
-     * @param {Condition} condition1
-     * @param {GroupOperator} operator
-     * @param {Condition} condition2
-     */
-    private static group;
-    static attribute(attr: string): AttributeOption;
-    /**
-     * @summary Condition Builder Class
-     * @description provides a simple API to build {@link Condition}s
-     *
-     * @class ConditionBuilder
-     * @implements Builder
-     * @implements AttributeOption
-     *
-     * @category Query
-     * @subcategory Conditions
-     */
-    private static Builder;
-    static get builder(): ConditionBuilderOption;
-}

package/lib/query/Paginator.d.ts

@@ -1,22 +0,0 @@
-import { Statement } from "./Statement";
-export declare abstract class Paginator<V, Q> {
-    protected stat: Statement<Q>;
-    readonly size: number;
-    protected readonly _rawStatement: Q;
-    protected _currentPage: number;
-    protected _totalPages: number;
-    protected _recordCount: number;
-    protected limit: number;
-    private _statement?;
-    get current(): number;
-    get total(): number;
-    get count(): number;
-    get statement(): Q;
-    protected get adapter(): import("..").Adapter<any, Q>;
-    protected constructor(stat: Statement<Q>, size: number, _rawStatement: Q);
-    protected abstract prepare(rawStatement: Q): Q;
-    next(): Promise<V[]>;
-    previous(): Promise<V[]>;
-    protected validatePage(page: number): void;
-    abstract page(page?: number, ...args: any[]): Promise<V[]>;
-}