lumen-framework 3.0.0

package/dist/types/packages/database/model/initialize-class.d.ts

@@ -0,0 +1,10 @@
+import type Database from '../index';
+import type { ModelClass } from '../interfaces';
+/**
+ * @private
+ */
+export default function initializeClass<T extends ModelClass>({ store, table, model }: {
+    store: Database;
+    table: T['table'];
+    model: T;
+}): Promise<T>;

package/dist/types/packages/database/model/interfaces.d.ts

@@ -0,0 +1,14 @@
+import type Model from './index';
+export type Model$Hook = (instance: Model, trx: unknown) => Promise<unknown>;
+export interface Model$Hooks {
+    readonly afterCreate?: Model$Hook;
+    readonly afterDestroy?: Model$Hook;
+    readonly afterSave?: Model$Hook;
+    readonly afterUpdate?: Model$Hook;
+    readonly afterValidation?: Model$Hook;
+    readonly beforeCreate?: Model$Hook;
+    readonly beforeDestroy?: Model$Hook;
+    readonly beforeSave?: Model$Hook;
+    readonly beforeUpdate?: Model$Hook;
+    readonly beforeValidation?: Model$Hook;
+}

package/dist/types/packages/database/model/utils/get-columns.d.ts

@@ -0,0 +1,5 @@
+import type Model from '../index';
+/**
+ * @private
+ */
+export default function getColumns(record: Model, only?: Array<string>): Record<string, unknown>;

package/dist/types/packages/database/model/utils/persistence.d.ts

@@ -0,0 +1,18 @@
+import type Logger from '../../../logger';
+import type Model from '../index';
+/**
+ * @private
+ */
+export declare function create(record: Model, trx: unknown): Array<any>;
+/**
+ * @private
+ */
+export declare function update(record: Model, trx: unknown): Array<any>;
+/**
+ * @private
+ */
+export declare function destroy(record: Model, trx: unknown): Array<any>;
+/**
+ * @private
+ */
+export declare function createRunner(logger: Logger, statements: Array<any>): (query: Array<any>) => Promise<Array<any>>;

package/dist/types/packages/database/model/utils/process-write-error.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function resolveWriteError(err: Error): Error;

package/dist/types/packages/database/model/utils/run-hooks.d.ts

@@ -0,0 +1,6 @@
+import type Model from '../index';
+import type { Model$Hook } from '../interfaces';
+/**
+ * @private
+ */
+export default function runHooks(record: Model, trx: unknown, ...hooks: Array<Model$Hook | undefined>): Promise<unknown>;

package/dist/types/packages/database/model/utils/validate.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from '../../index';
+/**
+ * @private
+ */
+export default function validate(instance: Model): true;

package/dist/types/packages/database/query/errors/index.d.ts

@@ -0,0 +1 @@
+export { default as RecordNotFoundError } from './record-not-found-error';

package/dist/types/packages/database/query/errors/record-not-found-error.d.ts

@@ -0,0 +1,6 @@
+import type { ModelClass } from '../../interfaces';
+declare class RecordNotFoundError extends Error {
+    constructor({ name, primaryKey }: ModelClass, primaryKeyValue: unknown);
+}
+declare const _default: new (...args: Array<any>) => RecordNotFoundError & import("../../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/database/query/index.d.ts

@@ -0,0 +1,38 @@
+import type { ModelClass } from '../interfaces';
+/**
+ * @class Query
+ * @extends Promise
+ * @private
+ */
+declare class Query<T = any> extends Promise<T> {
+    model: ModelClass;
+    isFind: boolean;
+    snapshots: Array<Array<any>>;
+    collection: boolean;
+    shouldCount: boolean;
+    relationships: Record<string, any>;
+    constructor(model: ModelClass);
+    static get [Symbol.species](): PromiseConstructor;
+    all(): this;
+    not(conditions?: Record<string, any>): this;
+    find(primaryKey: any): this;
+    page(num?: number): this;
+    limit(amount?: number): this;
+    order(attr: string, direction?: string): this;
+    where(conditions?: Record<string, any>, not?: boolean): this;
+    whereBetween(conditions: Record<string, any>, not?: boolean): this;
+    whereRaw(query: string, bindings?: Array<any>): this;
+    first(): this;
+    last(): this;
+    count(): Query<number>;
+    offset(amount: number): this;
+    select(...attrs: Array<string>): this;
+    distinct(...attrs: Array<string>): this;
+    include(...relationships: Array<Record<string, any> | string>): this;
+    unscope(...scopes: Array<string>): this;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((error: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((error: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    static from(src: any): Query<unknown>;
+}
+export default Query;
+export { RecordNotFoundError } from './errors';

package/dist/types/packages/database/query/runner/constants.d.ts

@@ -0,0 +1,2 @@
+import type Query from '../index';
+export declare const RUNNERS: WeakMap<Query<unknown>, () => Promise<void>>;

package/dist/types/packages/database/query/runner/index.d.ts

@@ -0,0 +1,9 @@
+import type Query from '../index';
+/**
+ * @private
+ */
+export declare function createRunner(target: Query<unknown>, opts: {
+    resolve?: (value: any) => void;
+    reject?: (error: Error) => void;
+}): void;
+export declare function runQuery(target: Query<unknown>): void;

package/dist/types/packages/database/query/runner/utils/build-results.d.ts

@@ -0,0 +1,10 @@
+import type Model from '../../../model';
+import type { ModelClass } from '../../../interfaces';
+/**
+ * @private
+ */
+export default function buildResults<T extends Model>({ model, records, relationships }: {
+    model: ModelClass<T>;
+    records: Promise<Array<Record<string, any>>>;
+    relationships: Record<string, any>;
+}): Promise<Array<T>>;

package/dist/types/packages/database/query/runner/utils/get-find-param.d.ts

@@ -0,0 +1,2 @@
+import type Query from '../../index';
+export default function getFindParam({ isFind, snapshots, model: { tableName, primaryKey } }: Query<unknown>): unknown;

package/dist/types/packages/database/query/utils/format-select.d.ts

@@ -0,0 +1,5 @@
+import type { ModelClass } from '../../interfaces';
+/**
+ * @private
+ */
+export default function formatSelect(model: ModelClass, attrs?: Array<string>, prefix?: string): string[];

package/dist/types/packages/database/query/utils/scopes-for.d.ts

@@ -0,0 +1,2 @@
+import type Query from '../index';
+export default function scopesFor<T>(target: Query<T>): PropertyDescriptorMap;

package/dist/types/packages/database/relationship/index.d.ts

@@ -0,0 +1,11 @@
+import type Model from '../model';
+/**
+ * @private
+ */
+export declare function set(owner: Model, key: string, value?: Array<Model> | Model | null): void;
+/**
+ * @private
+ */
+export declare function get(owner: Model, key: string): Promise<Array<Model> | Model | null>;
+export { default as updateRelationship } from './utils/update-relationship';
+export type { Relationship$opts } from './interfaces';

package/dist/types/packages/database/relationship/interfaces.d.ts

@@ -0,0 +1,12 @@
+import type { Model } from '../index';
+import type { ModelClass } from '../interfaces';
+type Relationship$ref = Model | Array<Model>;
+export type Relationship$refs = WeakMap<Model, Map<string, Relationship$ref>>;
+export type Relationship$opts = {
+    type: 'hasOne' | 'hasMany' | 'belongsTo';
+    model: ModelClass;
+    inverse: string;
+    through?: ModelClass;
+    foreignKey: string;
+};
+export {};

package/dist/types/packages/database/relationship/utils/getters.d.ts

@@ -0,0 +1,14 @@
+import type Model from '../../model';
+import type { Relationship$opts } from '../index';
+/**
+ * @private
+ */
+export declare function getHasOne(owner: Model, { model, foreignKey }: Relationship$opts): import("../..").Query<Model>;
+/**
+ * @private
+ */
+export declare function getHasMany(owner: Model, opts: Relationship$opts): Promise<Model[]>;
+/**
+ * @private
+ */
+export declare function getBelongsTo(owner: Model, { model, foreignKey }: Relationship$opts): import("../..").Query<Model> | Promise<null>;

package/dist/types/packages/database/relationship/utils/inverse-setters.d.ts

@@ -0,0 +1,15 @@
+import type Model from '../../model';
+import type { ModelClass } from '../../interfaces';
+import type { Relationship$opts } from '../index';
+/**
+ * @private
+ */
+export declare function setHasManyInverse(owner: Model, value: Array<Model>, { inverse, foreignKey, inverseModel }: Relationship$opts & {
+    inverseModel: ModelClass;
+}): void;
+/**
+ * @private
+ */
+export declare function setHasOneInverse(owner: Model, value: Model | null | undefined, { inverse, foreignKey, inverseModel }: Relationship$opts & {
+    inverseModel: ModelClass;
+}): void;

package/dist/types/packages/database/relationship/utils/setters.d.ts

@@ -0,0 +1,14 @@
+import type Model from '../../model';
+import type { Relationship$opts } from '../index';
+/**
+ * @private
+ */
+export declare function setHasMany(owner: Model, key: string, value: Array<Model>, { type, model, inverse, foreignKey }: Relationship$opts): void;
+/**
+ * @private
+ */
+export declare function setHasOne(owner: Model, key: string, value: Model | null | undefined, { type, model, inverse, foreignKey }: Relationship$opts): void;
+/**
+ * @private
+ */
+export declare function setBelongsTo(owner: Model, key: string, value: Model | null | undefined, { type, model, inverse, foreignKey }: Relationship$opts): void;

package/dist/types/packages/database/relationship/utils/unassociate.d.ts

@@ -0,0 +1,5 @@
+import type Model from '../../model';
+/**
+ * @private
+ */
+export default function unassociate<T extends Model>(value: Array<T>, foreignKey: string): Array<T>;

package/dist/types/packages/database/relationship/utils/update-relationship.d.ts

@@ -0,0 +1,5 @@
+import type Model from '../../model';
+/**
+ * @private
+ */
+export default function updateRelationship(record: Model, name: string, trx: unknown): Array<unknown>;

package/dist/types/packages/database/relationship/utils/validate-type.d.ts

@@ -0,0 +1,2 @@
+import type { ModelClass } from '../../interfaces';
+export default function validateType(model: ModelClass, value: unknown): boolean;

package/dist/types/packages/database/transaction/index.d.ts

@@ -0,0 +1,16 @@
+import type { Model } from '../index';
+import type { ModelClass } from '../interfaces';
+import type { Transaction$ResultProxy } from './interfaces';
+/**
+ * @private
+ */
+export declare function createStaticTransactionProxy<T extends ModelClass>(target: T, trx: unknown): T;
+/**
+ * @private
+ */
+export declare function createInstanceTransactionProxy<T extends Model>(target: T, trx: unknown): T;
+/**
+ * @private
+ */
+export declare function createTransactionResultProxy<T extends Model, U extends boolean>(record: T, didPersist: U): Transaction$ResultProxy<T, U>;
+export type { Transaction$ResultProxy } from './interfaces';

package/dist/types/packages/database/transaction/interfaces.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from '../index';
+export type Transaction$ResultProxy<T extends Model, U extends boolean> = T & {
+    didPersist: U;
+    unwrap(): T;
+};

package/dist/types/packages/database/utils/connect.d.ts

@@ -0,0 +1,6 @@
+import type { Knex } from 'knex';
+import type { Database$environment } from '../interfaces';
+/**
+ * @private
+ */
+export default function connect(path: string, config: Database$environment): Knex;

package/dist/types/packages/database/utils/create-migrations.d.ts

@@ -0,0 +1,5 @@
+import type Database from '../index';
+/**
+ * @private
+ */
+export default function createMigrations(schema: Database['schema']): Promise<boolean>;

package/dist/types/packages/database/utils/normalize-model-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare const _default: (input: unknown) => string;
+export default _default;

package/dist/types/packages/database/utils/pending-migrations.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function pendingMigrations(appPath: string, table: () => any): Promise<Array<string>>;

package/dist/types/packages/database/utils/type-for-column.d.ts

@@ -0,0 +1,5 @@
+import type { Database$column } from '../interfaces';
+/**
+ * @private
+ */
+export default function typeForColumn(column: Database$column): string | undefined;

package/dist/types/packages/database/validation/errors/index.d.ts

@@ -0,0 +1 @@
+export { default as ValidationError } from './validation-error';

package/dist/types/packages/database/validation/errors/validation-error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @private
+ */
+declare class ValidationError extends Error {
+    constructor(key: string, value: string);
+}
+export default ValidationError;

package/dist/types/packages/database/validation/index.d.ts

@@ -0,0 +1,13 @@
+import type { Validation$opts } from './interfaces';
+/**
+ * @private
+ */
+declare class Validation<T> {
+    key: string;
+    value: T;
+    validator: (value?: T) => boolean;
+    constructor(opts: Validation$opts<T>);
+    isValid(): boolean;
+}
+export default Validation;
+export { ValidationError } from './errors';

package/dist/types/packages/database/validation/interfaces.d.ts

@@ -0,0 +1,5 @@
+export type Validation$opts<T> = {
+    key: string;
+    value: T;
+    validator: (value?: T) => boolean;
+};

package/dist/types/packages/freezeable/constants.d.ts

@@ -0,0 +1 @@
+export declare const FREEZER: WeakSet<object>;

package/dist/types/packages/freezeable/index.d.ts

@@ -0,0 +1,3 @@
+export { default as FreezeableMap } from './map';
+export { default as FreezeableSet } from './set';
+export { freezeArray, freezeValue, freezeProps, deepFreezeProps } from './utils/freeze';

package/dist/types/packages/freezeable/map/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @private
+ */
+declare class FreezeableMap<K, V> extends Map<K, V> {
+    set(key: K, value: V): this;
+    clear(): void;
+    delete(key: K): boolean;
+    freeze(deep?: boolean): this;
+    isFrozen(): boolean;
+}
+export default FreezeableMap;

package/dist/types/packages/freezeable/set/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @private
+ */
+declare class FreezeableSet<T> extends Set<T> {
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    freeze(deep?: boolean): this;
+    isFrozen(): boolean;
+}
+export default FreezeableSet;

package/dist/types/packages/freezeable/utils/freeze.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @private
+ */
+export default function freeze<T extends object>(value: T): T;
+/**
+ * @private
+ */
+export declare function freezeArray<T>(target: T[]): readonly T[];
+/**
+ * @private
+ */
+export declare function freezeValue<T>(value: T): T;
+/**
+ * @private
+ */
+export declare function freezeProps<T extends object>(target: T, makePublic: boolean, ...props: string[]): T;
+/**
+ * @private
+ */
+export declare function deepFreezeProps<T extends object>(target: T, makePublic: boolean, ...props: string[]): T;

package/dist/types/packages/freezeable/utils/is-frozen.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function isFrozen(value: unknown): boolean;

package/dist/types/packages/fs/index.d.ts

@@ -0,0 +1,52 @@
+import type { Stats } from 'fs';
+import Watcher from './watcher';
+import type { fs$readOpts, fs$writeOpts } from './interfaces';
+export { default as rmrf } from './utils/rmrf';
+export { default as exists } from './utils/exists';
+export { default as isJSFile } from './utils/is-js-file';
+export { default as parsePath } from './utils/parse-path';
+export type { fs$ParsedPath } from './interfaces';
+/**
+ * @private
+ */
+export declare function watch(path: string): Promise<Watcher>;
+/**
+ * @private
+ */
+export declare function stat(path: string): Promise<Stats>;
+/**
+ * @private
+ */
+export declare function mkdir(path: string, mode?: number): Promise<void>;
+/**
+ * @private
+ */
+export declare function mkdirRec(path: string, mode?: number): Promise<void>;
+/**
+ * @private
+ */
+export declare function rmdir(path: string): Promise<void>;
+/**
+ * @private
+ */
+export declare function readdir(path: string, opts?: fs$readOpts): Promise<Array<string>>;
+/**
+ * @private
+ */
+export declare function readdirRec(path: string, opts?: fs$readOpts): Promise<Array<string>>;
+/**
+ * @private
+ */
+export declare function readFile(path: string, opts?: fs$readOpts): Promise<string | Buffer>;
+/**
+ * @private
+ */
+export declare function writeFile(path: string, data: string | Buffer, opts?: fs$writeOpts): Promise<void>;
+/**
+ * @private
+ */
+export declare function appendFile(path: string, data: string | Buffer, opts?: fs$writeOpts): Promise<void>;
+/**
+ * @private
+ */
+export declare function unlink(path: string): Promise<void>;

package/dist/types/packages/fs/interfaces.d.ts

@@ -0,0 +1,19 @@
+export type fs$writeOpts = string | {
+    mode?: number;
+    flag?: string;
+    encoding?: string | null;
+};
+export type fs$readOpts = string | {
+    flag?: string;
+    encoding?: string | null;
+};
+export type fs$PathRemover = (source: string) => string;
+export interface fs$ParsedPath {
+    root: string;
+    dir: string;
+    base: string;
+    ext: string;
+    name: string;
+    relative: string;
+    absolute: string;
+}

package/dist/types/packages/fs/utils/create-path-remover.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare function createPathRemover(path: string): (src: string) => string;
+export default createPathRemover;

package/dist/types/packages/fs/utils/create-resolver.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function createResolver(resolve: (data: any) => void, reject: (err: Error) => void): (err: Error | null, ...args: Array<any>) => void;

package/dist/types/packages/fs/utils/exists.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function exists(path: string | RegExp, dir?: string): Promise<boolean>;

package/dist/types/packages/fs/utils/is-js-file.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function isJSFile(target: string): boolean;

package/dist/types/packages/fs/utils/parse-path.d.ts

@@ -0,0 +1,5 @@
+import type { fs$ParsedPath } from '../index';
+/**
+ * @private
+ */
+export default function resolvePath(cwd?: string, dir?: string, name?: string): fs$ParsedPath;

package/dist/types/packages/fs/utils/rmrf.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare function rmrf(target: string): Promise<boolean>;
+export default rmrf;

package/dist/types/packages/fs/watcher/index.d.ts

@@ -0,0 +1,13 @@
+import EventEmitter from 'events';
+import type { FSWatcher } from 'fs';
+import { Client } from 'fb-watchman';
+/**
+ * @private
+ */
+declare class Watcher extends EventEmitter {
+    path: string;
+    client: Client | FSWatcher;
+    constructor(path: string, useWatchman?: boolean);
+    destroy(): void;
+}
+export default Watcher;

package/dist/types/packages/fs/watcher/initialize.d.ts

@@ -0,0 +1,5 @@
+import type Watcher from './index';
+/**
+ * @private
+ */
+export default function initialize<T extends Watcher>(instance: T, path: string, useWatchman: boolean): Promise<T>;

package/dist/types/packages/fs/watcher/interfaces.d.ts

@@ -0,0 +1,3 @@
+import type { FSWatcher } from 'fs';
+import type { Client } from 'fb-watchman';
+export type Watcher$Client = Client | FSWatcher;

package/dist/types/packages/jsonapi/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "1.0";
+export declare const MIME_TYPE = "application/vnd.api+json";

package/dist/types/packages/jsonapi/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { default as NotAcceptableError } from './not-acceptable-error';
+export { default as UnsupportedMediaTypeError } from './unsupported-media-type-error';
+export { default as InvalidContentTypeError } from './invalid-content-type-error';

package/dist/types/packages/jsonapi/errors/invalid-content-type-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private
+ */
+declare class InvalidContentTypeError extends TypeError {
+    constructor(contentType?: string);
+}
+declare const _default: new (...args: Array<any>) => InvalidContentTypeError & import("../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/jsonapi/errors/not-acceptable-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private
+ */
+declare class NotAcceptableError extends TypeError {
+    constructor(contentType: string);
+}
+declare const _default: new (...args: Array<any>) => NotAcceptableError & import("../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/jsonapi/errors/unsupported-media-type-error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @private
+ */
+declare class UnsupportedMediaTypeError extends TypeError {
+    constructor(contentType: string);
+}
+declare const _default: new (...args: Array<any>) => UnsupportedMediaTypeError & import("../../server/interfaces").Server$Error;
+export default _default;

package/dist/types/packages/jsonapi/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './errors';
+export { default as isJSONAPI } from './utils/is-jsonapi';
+export { default as hasMediaType } from './utils/has-media-type';
+export type { JSONAPI$versions, JSONAPI$Document, JSONAPI$ErrorObject, JSONAPI$DocumentLinks, JSONAPI$ResourceObject, JSONAPI$IdentifierObject, JSONAPI$RelationshipObject } from './interfaces';