@luminix/core 0.0.1-beta.3 → 0.0.1-beta.4

package/dist/types/Config.d.ts

@@ -0,0 +1,29 @@
+import { PropertyBag } from './PropertyBag';
+import { ModelSchema } from './Model';
+import { RouteDefinition } from './Route';
+
+export type AppConfiguration = {
+    app?: {
+        env?: string;
+        debug?: boolean;
+        url?: string;
+        bootUrl?: string | null | false;
+        enforceCamelCaseForModelAttributes?: boolean;
+        [key: string]: unknown;
+    };
+    auth?: {
+        user: {
+            id: number;
+            name: string;
+            email: string;
+            [key: string]: unknown;
+        } | null;
+        csrf?: string;
+    };
+    manifest?: {
+        models?: ModelSchema;
+        routes?: RouteDefinition;
+    };
+    [key: string]: unknown;
+};
+export type ConfigFacade = PropertyBag<AppConfiguration>;

package/dist/types/Error.d.ts

@@ -0,0 +1,31 @@
+import { default as PropertyBag } from '../contracts/PropertyBag';
+import { Event, EventSource } from './Event';
+import { PropertyBagEventMap } from './PropertyBag';
+
+export type ErrorEventMap = {
+    change: (e: ErrorChangeEvent) => void;
+};
+export type ErrorChangeEvent = Event<ErrorFacade> & {
+    value: string | null;
+    key: string;
+};
+export type ErrorBag = EventSource<PropertyBagEventMap> & 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;
+};
+export type ValidationError = Error & {
+    response: {
+        status: 422;
+        data: {
+            message: string;
+            errors: {
+                [key: string]: string[];
+            };
+        };
+    };
+};

package/dist/types/Event.d.ts

@@ -0,0 +1,14 @@
+import { Unsubscribe } from 'nanoevents';
+
+export type Event<S = any> = {
+    source: S;
+};
+export type EventSourceEvents = {
+    [event: string]: (e: any) => void;
+};
+export type EventSource<T extends EventSourceEvents> = {
+    on<E extends keyof T>(event: E, callback: T[E]): Unsubscribe;
+    once<E extends keyof T>(event: E, callback: T[E]): void;
+    emit<E extends keyof T>(event: E, data?: EventData<T, E>): void;
+};
+export type EventData<T extends EventSourceEvents, E extends keyof T> = Omit<Parameters<T[E]>[0], 'source'>;

package/dist/types/Log.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A facade for logging messages. Provides eight logging levels, defined in the RFC 5424 standard.
+ */
+export type LogFacade = {
+    /**
+     * System is unusable. (Code: 0)
+     */
+    emergency(...args: any[]): void;
+    /**
+     * Action must be taken immediately. (Code: 1)
+     */
+    alert(...args: any[]): void;
+    /**
+     * Critical conditions. (Code: 2)
+     */
+    critical(...args: any[]): void;
+    /**
+     * Error conditions. (Code: 3)
+     */
+    error(...args: any[]): void;
+    /**
+     * Warning conditions. (Code: 4)
+     */
+    warning(...args: any[]): void;
+    /**
+     * Normal but significant condition. (Code: 5)
+     */
+    notice(...args: any[]): void;
+    /**
+     * Informational messages. (Code: 6)
+     */
+    info(...args: any[]): void;
+    /**
+     * Debug-level messages. (Code: 7)
+     */
+    debug(...args: any[]): void;
+};

package/dist/types/Model.d.ts

@@ -0,0 +1,165 @@
+import { AxiosResponse } from 'axios';
+import { EventSource, Event } from './Event';
+import { Collection } from './Collection';
+import { RelationInterface, BuilderInterface, Scope, ExtendedOperator } from './Relation';
+import { JsonObject, JsonValue } from './Support';
+
+export type RelationRepository = Record<string, RelationInterface<Model, ModelPaginatedResponse>>;
+export type ModelEvents = {
+    'change': (e: ModelChangeEvent) => void;
+    'save': (e: ModelSaveEvent) => void;
+    'delete': (e: ModelDeleteEvent) => void;
+    'restore': (e: ModelRestoreEvent) => void;
+    'create': (e: ModelSaveEvent) => void;
+    'update': (e: ModelSaveEvent) => void;
+    'error': (e: ModelErrorEvent) => void;
+};
+export type ModelChangeEvent = Event<BaseModel> & {
+    value: JsonObject;
+};
+export type ModelSaveEvent = Event<BaseModel> & {
+    value: JsonObject;
+};
+export type ModelDeleteEvent = Event<BaseModel> & {
+    force: boolean;
+};
+export type ModelRestoreEvent = Event<BaseModel> & {
+    value: JsonObject;
+};
+export type ModelErrorEvent = Event<BaseModel> & {
+    error: unknown;
+    operation: 'save' | 'delete' | 'restore' | 'forceDelete';
+};
+export declare class BaseModel implements EventSource<ModelEvents> {
+    constructor(attributes?: JsonObject);
+    get attributes(): JsonObject;
+    get original(): JsonObject;
+    get primaryKey(): string;
+    get timestamps(): boolean;
+    get fillable(): string[];
+    get relations(): RelationRepository;
+    get isDirty(): boolean;
+    get casts(): ModelSchemaAttributes['casts'];
+    exists: boolean;
+    getAttribute(key: string): unknown;
+    setAttribute(key: string, value: unknown): void;
+    getKey(): string | number;
+    getKeyName(): string;
+    fill(attributes: JsonObject): void;
+    toJson(): JsonObject;
+    diff(): JsonObject;
+    getType(): string;
+    dump(): void;
+    save(options?: ModelSaveOptions): Promise<AxiosResponse<unknown, unknown>>;
+    update(attributes: JsonObject): Promise<void>;
+    delete(): Promise<AxiosResponse<unknown, unknown>>;
+    forceDelete(): Promise<AxiosResponse<unknown, unknown>>;
+    restore(): Promise<AxiosResponse<unknown, unknown>>;
+    refresh(): Promise<void>;
+    relation(relationName: string): RelationInterface<Model, ModelPaginatedResponse> | undefined;
+    static getSchemaName(): string;
+    static getSchema(): ModelSchemaAttributes;
+    static query(): BuilderInterface<Model, ModelPaginatedResponse>;
+    static get(page?: number, replaceLinksWith?: string): Promise<ModelPaginatedResponse>;
+    static find(id: number | string): Promise<Model | null>;
+    static first(): Promise<Model | null>;
+    static where(scope: Scope<Model, ModelPaginatedResponse>): BuilderInterface<Model, ModelPaginatedResponse>;
+    static where(key: string, value: JsonValue): BuilderInterface<Model, ModelPaginatedResponse>;
+    static where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface<Model, ModelPaginatedResponse>;
+    static where(key: string | Scope<Model, ModelPaginatedResponse>, operatorOrValue?: ExtendedOperator | JsonValue, value?: JsonValue): BuilderInterface<Model, ModelPaginatedResponse>;
+    static whereNull(key: string): BuilderInterface<Model, ModelPaginatedResponse>;
+    static whereNotNull(key: string): BuilderInterface<Model, ModelPaginatedResponse>;
+    static whereBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<Model, ModelPaginatedResponse>;
+    static whereNotBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<Model, ModelPaginatedResponse>;
+    static orderBy(column: string, direction?: 'asc' | 'desc'): BuilderInterface<Model, ModelPaginatedResponse>;
+    static searchBy(term: string): BuilderInterface<Model, ModelPaginatedResponse>;
+    static minified(): BuilderInterface<Model, ModelPaginatedResponse>;
+    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 singular(): string;
+    static plural(): string;
+    on: EventSource<ModelEvents>['on'];
+    once: EventSource<ModelEvents>['once'];
+    emit: EventSource<ModelEvents>['emit'];
+}
+export declare class Model extends BaseModel {
+    [key: string]: any;
+    [Symbol.toStringTag]: string;
+}
+export interface ModelSaveOptions {
+    additionalPayload?: object;
+    sendsOnlyModifiedFields?: boolean;
+}
+export type ModelFillCallback = (data: object) => void;
+export type ModelJsonCallback = () => object;
+export type ModelDiffCallback = () => object | false;
+export type ModelSaveCallback = (options?: ModelSaveOptions) => Promise<boolean>;
+export interface ModelTableColumnDefinition {
+    key: string;
+    label: string;
+    sortable?: boolean;
+}
+export interface ModelSchemaAttributes {
+    displayName: {
+        singular: string;
+        plural: string;
+    };
+    fillable: string[];
+    relations: Record<string, Omit<RelationMetaData, 'name'>>;
+    casts: Record<string, string>;
+    primaryKey: string;
+    timestamps: boolean;
+    labeledBy: string;
+}
+export interface RelationMetaData {
+    model: string;
+    type: 'HasOne' | 'HasMany' | 'BelongsTo' | 'BelongsToMany' | 'MorphOne' | 'MorphMany' | 'MorphTo' | 'MorphToMany' | 'MorphedByMany';
+    foreignKey: string | null;
+    name: string;
+}
+export interface ModelSchema {
+    [abstract: string]: ModelSchemaAttributes;
+}
+export type ModelQuery = JsonObject & {
+    q?: string;
+    page?: number;
+    per_page?: number;
+    order_by?: string;
+    where?: JsonObject;
+    tab?: string;
+    minified?: boolean;
+};
+export type ModelGetOptions = {
+    query?: ModelQuery;
+    linkBase?: string;
+};
+export type ModelPaginatedLink = {
+    url: string | null;
+    label: string;
+    active: boolean;
+};
+export type ModelPaginatedResponse = {
+    data: Collection<Model>;
+    links: {
+        first: string;
+        last: string;
+        prev: string | null;
+        next: string | null;
+    };
+    meta: {
+        current_page: number;
+        from: number;
+        last_page: number;
+        per_page: number;
+        to: number;
+        total: number;
+        links: Array<ModelPaginatedLink>;
+    };
+};

package/dist/types/Plugin.d.ts

@@ -0,0 +1,4 @@
+export type PluginInterface<A, F> = {
+    register(app: A): void;
+    boot(facades: F): void;
+};

package/dist/types/PropertyBag.d.ts

@@ -0,0 +1,25 @@
+import { Unsubscribe } from 'nanoevents';
+import { Event } from './Event';
+
+export type PropertyBagChangeEvent<T extends object> = Event<PropertyBag<T>> & {
+    path: string;
+    value: unknown;
+    type: 'set' | 'merge' | 'delete';
+};
+export type PropertyBagEventMap<T extends object = any> = {
+    'change': (e: PropertyBagChangeEvent<T>) => void;
+};
+export type PropertyBag<T extends object> = {
+    get(path: string, defaultValue?: unknown): unknown;
+    set(path: string, value: unknown): void;
+    merge(path: string, value: unknown): void;
+    has(path: string): boolean;
+    delete(path: string): void;
+    lock(path: string): void;
+    clone(): PropertyBag<T>;
+    all(): T;
+    isEmpty(): boolean;
+    on<K extends keyof PropertyBagEventMap<T>>(event: K, callback: PropertyBagEventMap<T>[K]): Unsubscribe;
+    once<K extends keyof PropertyBagEventMap<T>>(event: K, callback: PropertyBagEventMap<T>[K]): void;
+    emit<K extends keyof PropertyBagEventMap<T>>(event: K, payload: Omit<Parameters<PropertyBagEventMap<T>[K]>[0], 'source'>): void;
+};

package/dist/types/Reducer.d.ts

@@ -0,0 +1,17 @@
+import { Collection } from './Collection';
+
+export type ReducerCallback = (value: any, ...params: any[]) => any;
+export interface Reducer {
+    callback: ReducerCallback;
+    priority: number;
+}
+export type Unsubscribe = () => void;
+export type ReducibleInterface = {
+    reducer(name: string, callback: ReducerCallback, priority?: number): Unsubscribe;
+    removeReducer(name: string, callback: ReducerCallback): void;
+    getReducer(name: string): Collection<Reducer>;
+    hasReducer(name: string): boolean;
+    clearReducer(name: string): void;
+    flushReducers(): void;
+    [reducer: string]: unknown;
+};

package/dist/types/Relation.d.ts

@@ -0,0 +1,30 @@
+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;
+    make(data: JsonValue): void;
+    set(items: R | Collection<R> | null): void;
+    getForeignKey(): string | null;
+    getName(): string;
+    getType(): string;
+    getModel(): string;
+    getRelated(): Constructor<R>;
+    isSingle(): boolean;
+    isMultiple(): boolean;
+    query(): BuilderInterface<R, C>;
+    isLoaded(): boolean;
+    getLoadedItems(): R | Collection<R> | null;
+    where(scope: Scope<R, C>): BuilderInterface<R, C>;
+    where(key: string, value: JsonValue): BuilderInterface<R, C>;
+    where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface<R, C>;
+    whereNull(key: string): BuilderInterface<R, C>;
+    whereNotNull(key: string): BuilderInterface<R, C>;
+    whereNotBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<R, C>;
+    orderBy(column: string, direction?: 'asc' | 'desc'): BuilderInterface<R, C>;
+    searchBy(term: string): BuilderInterface<R, C>;
+    minified(): BuilderInterface<R, C>;
+    limit(value: number): BuilderInterface<R, C>;
+};

package/dist/types/Route.d.ts

@@ -0,0 +1,22 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { ReducibleInterface } from './Reducer';
+
+export type RouteReplacer = {
+    [key: string]: string | number;
+};
+export type RouteFacade = ReducibleInterface & {
+    get(name: string): RouteTuple;
+    url(generator: RouteGenerator): string;
+    exists(name: string): boolean;
+    call(generator: RouteGenerator, config?: RouteCallConfig): Promise<AxiosResponse>;
+    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;
+};
+export type RouteCallConfig = Omit<AxiosRequestConfig, 'url'> & {
+    errorBag?: string;
+};

package/dist/types/Support.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminix/core",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.4",
   "description": "> Projeto em desenvolvimento",
   "main": "dist/core.js",
   "types": "dist/index.d.ts",

package/vite.config.js

@@ -1,12 +1,12 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
 
-//import dts from 'vite-plugin-dts';
+import dts from 'vite-plugin-dts';
 
 import packageJson from './package.json';
 
 export default defineConfig({
-    //plugins: [dts({ insertTypesEntry: true })],
+    plugins: [dts({ insertTypesEntry: true })],
     build: {
         lib: {
             entry: resolve(__dirname, 'src/index.ts'),