@luminix/core 0.0.1-beta.14 → 0.0.1-beta.153

package/types/services/RouteService.d.ts

@@ -0,0 +1,21 @@
+import { Client, Response } from '@luminix/support';
+import { RouteDefinition, RouteTuple as RouteTuple, HttpMethod, RouteGenerator, RouteReducers } from '../types/Route';
+import { ErrorFacade } from '../types/Error';
+export declare class RouteService {
+    protected routes: RouteDefinition;
+    protected error: ErrorFacade;
+    protected http: () => Client;
+    protected appUrl: string;
+    constructor(routes: RouteDefinition, error: ErrorFacade, http: () => Client, appUrl?: string);
+    private isRouteTuple;
+    private extractGenerator;
+    get(name: string): RouteTuple;
+    url(generator: RouteGenerator): string;
+    methods(generator: RouteGenerator): HttpMethod[];
+    exists(name: string): boolean;
+    call<TResponse = any>(generator: RouteGenerator, tap?: (client: Client) => Client, errorBag?: string): Promise<Response<TResponse>>;
+    toString(): string;
+    [reducer: string]: unknown;
+}
+declare const _default: import('@luminix/support').ReducibleOf<typeof RouteService, RouteReducers>;
+export default _default;

package/{dist → types}/support/model.d.ts

@@ -1,3 +1,3 @@
 import { Model } from '../types/Model';
-
+/** @deprecated */
 export declare function isModel(value: unknown): value is Model;

package/types/types/App.d.ts

@@ -0,0 +1,88 @@
+import { EventSource, Event, ReducibleInterface, FacadeOf, HasFacadeAccessor, Application, MacroableInterface, Constructor } from '@luminix/support';
+import { AppConfiguration, ConfigFacade } from './Config';
+import { PluginInterface } from './Plugin';
+import { LogFacade } from './Log';
+import { BaseModel, Model, ModelPaginatedResponse, ModelReducers, ModelSchema, ModelSchemaAttributes } from './Model';
+import { RouteFacade } from './Route';
+import { ErrorFacade } from './Error';
+import { RelationInterface } from './Relation';
+import { AuthFacade } from './Auth';
+import { HttpFacade } from './Http';
+type Plugin = PluginInterface<AppFacade, AppContainers>;
+export type GlobalModelEvents = {
+    'save': (e: ModelGlobalEvent) => void;
+    'delete': (e: ModelGlobalEvent) => void;
+    'restore': (e: ModelGlobalEvent) => void;
+    'create': (e: ModelGlobalEvent) => void;
+    'update': (e: ModelGlobalEvent) => void;
+    'fetch': (e: ModelGlobalEvent) => void;
+    'error': (e: ModelGlobalErrorEvent) => void;
+};
+export type ModelGlobalEvent = Event<{
+    class: string;
+    model: BaseModel;
+    force?: boolean;
+}, ModelFacade>;
+export type ModelGlobalErrorEvent = ModelGlobalEvent & {
+    error: unknown;
+    operation: 'save' | 'delete' | 'restore' | 'forceDelete';
+};
+export type ModelFacade = EventSource<GlobalModelEvents> & ModelReducers & ReducibleInterface<ModelReducers> & {
+    schema(): ModelSchema;
+    schema(abstract: string): ModelSchemaAttributes;
+    make(): Record<string, typeof Model>;
+    make(abstract: string): typeof Model;
+    boot(app: AppFacade): void;
+    getRelationConstructors(abstract: string): Record<string, Constructor<RelationInterface<Model, ModelPaginatedResponse>>>;
+};
+/** @deprecated */
+export type AppEvents = {
+    'init': (e: InitEvent) => void;
+    'booted': (e: Event<{}, AppFacade>) => void;
+    'booting': (e: Event<{}, AppFacade>) => void;
+};
+export type InitEvent = Event<{
+    register(plugin: Plugin): void;
+}, AppFacade>;
+/** @deprecated */
+export type AppExternal = {
+    boot: (config?: AppConfiguration) => Promise<AppContainers>;
+    /** @deprecated */
+    make(): AppContainers;
+    make<T extends keyof AppContainers>(key: T): AppContainers[T];
+    plugins: () => Plugin[];
+    on: EventSource<AppEvents>['once'];
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    getPlugin<T extends Plugin>(abstract: Constructor<T>): T | undefined;
+    getLocale(): string;
+    hasDebugModeEnabled(): boolean;
+    isLocal(): boolean;
+    isProduction(): boolean;
+    setInstance(app: AppFacade): void;
+};
+export type AppFacade = FacadeOf<Application<AppContainers> & AppMacros & MacroableInterface<AppMacros>, HasFacadeAccessor> & {
+    down(): void;
+};
+export declare class AppContainers {
+    auth: FacadeOf<AuthFacade, HasFacadeAccessor>;
+    config: FacadeOf<ConfigFacade, HasFacadeAccessor>;
+    error: FacadeOf<ErrorFacade, HasFacadeAccessor>;
+    http: FacadeOf<HttpFacade, HasFacadeAccessor>;
+    log: FacadeOf<LogFacade, HasFacadeAccessor>;
+    model: FacadeOf<ModelFacade, HasFacadeAccessor>;
+    route: FacadeOf<RouteFacade, HasFacadeAccessor>;
+    [key: string]: any;
+}
+export type BootOptions = {
+    config?: AppConfiguration;
+    skipBootRequest?: boolean;
+};
+export type AppMacros = {
+    environment(...environments: string[]): string | boolean;
+    getLocale(): string;
+    hasDebugModeEnabled(): boolean;
+    isLocal(): boolean;
+    isProduction(): boolean;
+};
+export {};

package/{dist → types}/types/Auth.d.ts

@@ -1,5 +1,4 @@
 import { Model } from './Model';
-
 export type AuthCredentials = {
     email: string;
     password: string;

package/types/types/Builder.d.ts

@@ -0,0 +1,46 @@
+import { EventSource, Collection, PropertyBag, Operator, Event, PropertyBagEventMap, JsonObject, JsonValue } from '@luminix/support';
+export type Scope<TSingle, TMany> = (builder: BuilderInterface<TSingle, TMany>) => BuilderInterface<TSingle, TMany> | void;
+export type ExtendedOperator = Operator | 'like' | 'notLike' | 'between' | 'notBetween' | 'null' | 'notNull';
+export type BuilderInterface<TSingle, TMany = Collection<TSingle>> = EventSource<BuilderEventMap<TSingle, TMany>> & {
+    lock(path: string): void;
+    where(scope: Scope<TSingle, TMany>): BuilderInterface<TSingle, TMany>;
+    where(key: string, value: JsonValue): BuilderInterface<TSingle, TMany>;
+    where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface<TSingle, TMany>;
+    where(key: string | Scope<TSingle, TMany>, operatorOrValue?: ExtendedOperator | JsonValue, value?: JsonValue): BuilderInterface<TSingle, TMany>;
+    with(relation: string | string[]): BuilderInterface<TSingle, TMany>;
+    withOnly(relation: string | string[]): BuilderInterface<TSingle, TMany>;
+    without(relation: string | string[]): BuilderInterface<TSingle, TMany>;
+    whereNull(key: string): BuilderInterface<TSingle, TMany>;
+    whereNotNull(key: string): BuilderInterface<TSingle, TMany>;
+    whereBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<TSingle, TMany>;
+    whereNotBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<TSingle, TMany>;
+    orderBy(column: string, direction?: 'asc' | 'desc'): BuilderInterface<TSingle, TMany>;
+    searchBy(term: string): BuilderInterface<TSingle, TMany>;
+    minified(): BuilderInterface<TSingle, TMany>;
+    limit(value: number): BuilderInterface<TSingle, TMany>;
+    include(searchParams: URLSearchParams): BuilderInterface<TSingle, TMany>;
+    get(page?: number, replaceLinksWith?: string): Promise<TMany>;
+    all(): Promise<Collection<TSingle>>;
+    first(): Promise<TSingle | null>;
+    find(id: string | number): Promise<TSingle | null>;
+    unset(key: string): BuilderInterface<TSingle, TMany>;
+};
+export type BuilderEventMap<TSingle, TMany> = PropertyBagEventMap & {
+    'change': (e: BuilderChangeEvent<TSingle, TMany>) => void;
+    'submit': (e: BuilderSubmitEvent<TSingle, TMany>) => void;
+    'success': (e: BuilderSuccessEvent<TSingle, TMany>) => void;
+    'error': (e: BuilderErrorEvent<TSingle, TMany>) => void;
+};
+export type BuilderChangeEvent<TSingle, TMany> = Event<{
+    data: PropertyBag<JsonObject>;
+}, BuilderInterface<TSingle, TMany>>;
+export type BuilderSubmitEvent<TSingle, TMany> = Event<{
+    data: PropertyBag<JsonObject>;
+}, BuilderInterface<TSingle, TMany>>;
+export type BuilderErrorEvent<TSingle, TMany> = Event<{
+    error: unknown;
+}, BuilderInterface<TSingle, TMany>>;
+export type BuilderSuccessEvent<TSingle, TMany> = Event<{
+    response: TMany;
+    items: TSingle | Collection<TSingle> | null;
+}, BuilderInterface<TSingle, TMany>>;

package/{dist → types}/types/Config.d.ts

@@ -1,13 +1,15 @@
-import { PropertyBag } from './PropertyBag';
+import { PropertyBag } from '@luminix/support';
 import { ModelSchema } from './Model';
 import { RouteDefinition } from './Route';
-
 export type AppConfiguration = {
     app?: {
+        name?: string;
         env?: string;
         debug?: boolean;
         url?: string;
+        port?: string | number;
         bootUrl?: string | null | false;
+        /** @deprecated */
         enforceCamelCaseForModelAttributes?: boolean;
         [key: string]: unknown;
     };

package/types/types/Error.d.ts

@@ -0,0 +1,17 @@
+import { PropertyBag } from '@luminix/support';
+export type ErrorBag = PropertyBag<Record<string, string>>;
+export type ErrorFacade = {
+    add(key: string, value: string, bag?: string): void;
+    set(errors: Record<string, string>, bag?: string): void;
+    get(key: string, bag?: string): string | null;
+    all(bag?: string): Record<string, string>;
+    clear(bag?: string): void;
+    bag(name?: string): ErrorBag;
+};
+/** @deprecated */
+export type ValidationError = {
+    message: string;
+    errors: {
+        [key: string]: string[];
+    };
+};

package/types/types/Http.d.ts

@@ -0,0 +1,20 @@
+import { Client, MacroableInterface, RequestOptions, Response } from '@luminix/support';
+export type HttpMacro = (...args: any) => Client;
+export type HttpFacade = Record<string, HttpMacro> & MacroableInterface<Record<string, HttpMacro>> & {
+    getClient(): Client;
+    baseUrl(baseUrl: string): Client;
+    asForm(): Client;
+    accept(type: string): Client;
+    acceptJson(): Client;
+    withHeaders(headers: Record<string, string>): Client;
+    withOptions(options: RequestOptions): Client;
+    withData(data: object): Client;
+    withQueryParameters(params: string | object): Client;
+    withBasicAuth(username: string, password: string): Client;
+    withToken(token: string): Client;
+    get<TResponse = any>(url: string, query?: string | object): Promise<Response<TResponse>>;
+    post<TResponse = any, TData = any>(url: string, data?: TData): Promise<Response<TResponse>>;
+    put<TResponse = any, TData = any>(url: string, data?: TData): Promise<Response<TResponse>>;
+    patch<TResponse = any, TData = any>(url: string, data?: TData): Promise<Response<TResponse>>;
+    delete<TResponse = any>(url: string, query?: string | object): Promise<Response<TResponse>>;
+};

package/{dist → types}/types/Model.d.ts

@@ -1,11 +1,9 @@
-import { AxiosResponse } from 'axios';
-import { EventSource, Event } from './Event';
-import { Collection } from './Collection';
-import { RelationInterface, BuilderInterface, Scope, ExtendedOperator } from './Relation';
+import { EventSource, Collection, Response, Event, Constructor } from '@luminix/support';
+import { RelationInterface as RawRelationInterface, BuilderInterface, Scope, ExtendedOperator } from './Relation';
 import { JsonObject, JsonValue } from './Support';
 import { RouteGenerator } from './Route';
-
-export type RelationRepository = Record<string, RelationInterface<Model, ModelPaginatedResponse>>;
+type RelationInterface = RawRelationInterface<Model, ModelPaginatedResponse>;
+export type RelationRepository = Record<string, RelationInterface>;
 export type ModelEvents = {
     'change': (e: ModelChangeEvent) => void;
     'save': (e: ModelSaveEvent) => void;
@@ -15,23 +13,29 @@ export type ModelEvents = {
     'update': (e: ModelSaveEvent) => void;
     'error': (e: ModelErrorEvent) => void;
 };
-export type ModelChangeEvent = Event<BaseModel> & {
-    value: JsonObject;
+export type ModelReducers = {
+    model(constructor: typeof BaseModel, abstract: string): typeof BaseModel;
+    relationMap(relationMap: Record<string, Constructor<RelationInterface>>, abstract: string): Record<string, Constructor<RelationInterface>>;
+    guessInverseRelation(relationMap: Record<string, string[]>, parent: BaseModel, relationType: string, relatedClass: typeof BaseModel): Record<string, string[]>;
+    [key: string]: (value: any, ...params: any[]) => any;
 };
-export type ModelSaveEvent = Event<BaseModel> & {
+export type ModelChangeEvent = Event<{
     value: JsonObject;
-};
-export type ModelDeleteEvent = Event<BaseModel> & {
+}, BaseModel>;
+export type ModelSaveEvent = Event<{
+    value: JsonObject;
+}, BaseModel>;
+export type ModelDeleteEvent = Event<{
     force: boolean;
-};
-export type ModelRestoreEvent = Event<BaseModel> & {
+}, BaseModel>;
+export type ModelRestoreEvent = Event<{
     value: JsonObject;
-};
-export type ModelErrorEvent = Event<BaseModel> & {
+}, BaseModel>;
+export type ModelErrorEvent = Event<{
     error: unknown;
     operation: 'save' | 'delete' | 'restore' | 'forceDelete';
-};
-export declare class BaseModel implements EventSource<ModelEvents> {
+}, BaseModel>;
+export declare class BaseModel extends EventSource<ModelEvents> {
     constructor(attributes?: JsonObject);
     get attributes(): JsonObject;
     get original(): JsonObject;
@@ -53,19 +57,17 @@ export declare class BaseModel implements EventSource<ModelEvents> {
     diff(): JsonObject;
     getType(): string;
     dump(): void;
-    save(options?: ModelSaveOptions): Promise<AxiosResponse | void>;
+    save(options?: ModelSaveOptions): Promise<Response | void>;
     update(attributes: JsonObject): Promise<void>;
-    delete(): Promise<AxiosResponse>;
-    forceDelete(): Promise<AxiosResponse>;
-    restore(): Promise<AxiosResponse>;
+    delete(): Promise<Response>;
+    forceDelete(): Promise<Response>;
+    restore(): Promise<Response>;
     refresh(): Promise<void>;
-    relation(relationName: string): RelationInterface<Model, ModelPaginatedResponse> | undefined;
+    relation(relationName: string): RelationInterface | undefined;
     getErrorBag(method: string): string;
     getRouteForSave(): RouteGenerator;
     getRouteForUpdate(): RouteGenerator;
     getRouteForDelete(): RouteGenerator;
-    getRouteForRestore(): RouteGenerator;
-    getRouteForForceDelete(): RouteGenerator;
     getRouteForRefresh(): RouteGenerator;
     static getSchemaName(): string;
     static getSchema(): ModelSchemaAttributes;
@@ -87,12 +89,12 @@ export declare class BaseModel implements EventSource<ModelEvents> {
     static limit(value: number): BuilderInterface<Model, ModelPaginatedResponse>;
     static create(attributes: JsonObject): Promise<Model>;
     static update(id: number | string, attributes: JsonObject): Promise<Model>;
-    static delete(id: number | string): Promise<AxiosResponse>;
-    static delete(ids: Array<number | string>): Promise<AxiosResponse>;
-    static restore(id: number | string): Promise<AxiosResponse>;
-    static restore(ids: Array<number | string>): Promise<AxiosResponse>;
-    static forceDelete(id: number | string): Promise<AxiosResponse>;
-    static forceDelete(ids: Array<number | string>): Promise<AxiosResponse>;
+    static delete(id: number | string): Promise<Response>;
+    static delete(ids: Array<number | string>): Promise<Response>;
+    static restore(id: number | string): Promise<Response>;
+    static restore(ids: Array<number | string>): Promise<Response>;
+    static forceDelete(id: number | string): Promise<Response>;
+    static forceDelete(ids: Array<number | string>): Promise<Response>;
     static singular(): string;
     static plural(): string;
     on: EventSource<ModelEvents>['on'];
@@ -173,6 +175,9 @@ export type ModelPaginatedLink = {
     label: string;
     active: boolean;
 };
+export type ModelRawPaginatedResponse = Omit<ModelPaginatedResponse, 'data'> & {
+    data: JsonObject[];
+};
 export type ModelPaginatedResponse = {
     data: Collection<Model>;
     links: {
@@ -191,3 +196,4 @@ export type ModelPaginatedResponse = {
         links: Array<ModelPaginatedLink>;
     };
 };
+export {};

package/{dist → types}/types/Relation.d.ts

@@ -1,7 +1,5 @@
+import { Collection, Constructor, JsonValue } from '@luminix/support';
 import { BuilderInterface, ExtendedOperator, Scope } from './Builder';
-import { Collection } from './Collection';
-import { Constructor, JsonValue } from './Support';
-
 export type { BuilderInterface, ExtendedOperator, Scope, };
 export type RelationInterface<R, C> = {
     guessInverseRelation(): string;

package/types/types/Route.d.ts

@@ -0,0 +1,28 @@
+import { ReducibleInterface, Response, Client, RequestOptions } from '@luminix/support';
+export type RouteReplacer = {
+    [key: string]: string | number;
+};
+export declare class RouteReducers {
+    clientOptions(config: RequestOptions, routeName: string): RequestOptions;
+    clientError(errors: Record<string, string>, event: {
+        response: Response;
+        name?: string;
+        replace?: RouteReplacer;
+        client: Client;
+    }): Record<string, string>;
+    replaceRouteParams(url: string): string;
+    [reducer: string]: (...args: any[]) => any;
+}
+export type RouteFacade = ReducibleInterface<RouteReducers> & {
+    get(name: string): RouteTuple;
+    url(generator: RouteGenerator): string;
+    exists(name: string): boolean;
+    call<TResponse = unknown>(generator: RouteGenerator, tap?: (client: Client) => Client, errorBag?: string): Promise<Response<TResponse>>;
+    methods(generator: RouteGenerator): HttpMethod[];
+};
+export type RouteGenerator = string | [string, RouteReplacer];
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export type RouteTuple = [string, ...HttpMethod[]];
+export type RouteDefinition = {
+    [routeName: string]: RouteTuple | RouteDefinition;
+};

package/{dist → types}/types/Support.d.ts

@@ -1,7 +1,8 @@
-export type TypeOf = 'string' | 'number' | 'boolean' | 'object' | 'undefined' | 'function' | 'symbol' | 'bigint';
+/** @deprecated */
 export type Constructor<T = {}> = new (...args: any[]) => T;
-export type Operator = '=' | '!=' | '>' | '<' | '>=' | '<=';
+/** @deprecated */
 export type JsonObject = {
     [key: string]: JsonValue;
 };
+/** @deprecated */
 export type JsonValue = string | number | boolean | null | JsonObject | Array<string | number | boolean | null | JsonObject>;

package/.eslintignore

@@ -1,3 +0,0 @@
-vite.config.js
-dist/
-coverage/

package/.eslintrc.cjs

@@ -1,39 +0,0 @@
-// eslint-disable-next-line no-undef
-module.exports = {
-    'env': {
-        'browser': true,
-        'es2021': true
-    },
-    'extends': [
-        'eslint:recommended',
-        'plugin:@typescript-eslint/recommended'
-    ],
-    'overrides': [
-    ],
-    'parser': '@typescript-eslint/parser',
-    'parserOptions': {
-        'ecmaVersion': 'latest',
-        'sourceType': 'module'
-    },
-    'plugins': [
-        '@typescript-eslint'
-    ],
-    'rules': {
-        'indent': [
-            'error',
-            4
-        ],
-        'linebreak-style': [
-            'error',
-            'unix'
-        ],
-        'quotes': [
-            'error',
-            'single'
-        ],
-        'semi': [
-            'error',
-            'always'
-        ]
-    }
-};

package/dist/contracts/Builder.d.ts

@@ -1,53 +0,0 @@
-import { Unsubscribe } from 'nanoevents';
-import { AppFacades } from '../types/App';
-import { BuilderEventMap as BuilderEvents, BuilderInterface as BuilderBase, ExtendedOperator } from '../types/Builder';
-import { EventData } from '../types/Event';
-import { Model, ModelPaginatedResponse, ModelQuery } from '../types/Model';
-import { JsonValue } from '../types/Support';
-import { Collection as CollectionInterface } from '../types/Collection';
-
-type BuilderInterface = BuilderBase<Model, ModelPaginatedResponse>;
-type BuilderEventMap = BuilderEvents<Model, ModelPaginatedResponse>;
-declare class Builder implements BuilderInterface {
-    protected facades: AppFacades;
-    protected abstract: string;
-    protected query: ModelQuery;
-    private bag;
-    constructor(facades: AppFacades, abstract: string, query?: ModelQuery);
-    on<T extends keyof BuilderEventMap>(_: T, __: BuilderEventMap[T]): Unsubscribe;
-    once<T extends keyof BuilderEventMap>(_: T, __: BuilderEventMap[T]): void;
-    emit<T extends keyof BuilderEventMap>(_: T, __: EventData<BuilderEventMap, T>): void;
-    lock(path: string): void;
-    whereBetween(key: string, value: [JsonValue, JsonValue]): this;
-    whereNotBetween(key: string, value: [JsonValue, JsonValue]): this;
-    whereNull(key: string): this;
-    whereNotNull(key: string): this;
-    limit(value: number): this;
-    where(scope: (builder: BuilderInterface) => BuilderInterface | void): this;
-    where(key: string, value: JsonValue): this;
-    where(key: string, operator: ExtendedOperator, value: JsonValue): this;
-    with(relation: string | string[]): this;
-    withOnly(relation: string | string[]): this;
-    without(relation: string | string[]): this;
-    orderBy(column: string, direction?: 'asc' | 'desc'): this;
-    searchBy(term: string): this;
-    minified(): this;
-    unset(key: string): this;
-    include(searchParams: URLSearchParams): this;
-    private exec;
-    get(page?: number, replaceLinksWith?: string): Promise<ModelPaginatedResponse>;
-    first(): Promise<Model | null>;
-    find(id: string | number): Promise<Model | null>;
-    all(): Promise<CollectionInterface<Model>>;
-}
-declare const _default: {
-    new (...args: any[]): {
-        emitter: import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        on<E extends "change" | "submit" | "success" | "error">(event: E, callback: BuilderEventMap[E]): Unsubscribe;
-        once<E_1 extends "change" | "submit" | "success" | "error">(event: E_1, callback: BuilderEventMap[E_1]): void;
-        emit<E_2 extends "change" | "submit" | "success" | "error">(event: E_2, data?: Omit<Parameters<BuilderEventMap[E_2]>[0], "source">): void;
-        [Symbol.toStringTag]: string;
-    };
-} & typeof Builder;
-export default _default;