@luminix/core 0.0.1-beta.1 → 0.0.1-beta.10

package/dist/exceptions/AttributeNotFillableException.d.ts

@@ -1,4 +1,4 @@
 export default class AttributeNotFillableException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(abstract: string, attribute: string);
 }

package/dist/exceptions/FacadeNotFoundException.d.ts

@@ -1,4 +1,4 @@
 export default class FacadeNotFoundException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(name: string);
 }

package/dist/exceptions/MethodNotImplementedException.d.ts

@@ -1,4 +1,4 @@
 export default class MethodNotImplementedException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor();
 }

package/dist/exceptions/ModelInvalidRelatedTypeException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelInvalidRelatedTypeException extends TypeError {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(caller: string, expectedType: string, relatedType: string);
 }

package/dist/exceptions/ModelNotFoundException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelNotFoundException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string);
 }

package/dist/exceptions/ModelNotPersistedException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelNotPersistedException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string, operation: string);
 }

package/dist/exceptions/ModelWithoutPrimaryKeyException.d.ts

@@ -1,4 +1,4 @@
 export default class ModelWithoutPrimaryKeyException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string);
 }

package/dist/exceptions/NoEmbedException.d.ts

@@ -1,4 +1,4 @@
 export default class NoEmbedException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor();
 }

package/dist/exceptions/NoInverseRelationException.d.ts

@@ -1,4 +1,4 @@
 export default class NoInverseRelationException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(model: string, relation: string, related: string, relatedRelation: string);
 }

package/dist/exceptions/NotModelException.d.ts

@@ -1,4 +1,4 @@
 export default class NotModelException extends TypeError {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(caller: string, expects?: string);
 }

package/dist/exceptions/NotReducibleException.d.ts

@@ -1,4 +1,4 @@
 export default class NotReducibleException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(facade: unknown);
 }

package/dist/exceptions/ReducerOverrideException.d.ts

@@ -1,4 +1,4 @@
 export default class ReducerOverrideException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(name: string, target: unknown);
 }

package/dist/exceptions/RouteNotFoundException.d.ts

@@ -1,4 +1,4 @@
 export default class RouteNotFoundException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(route: string);
 }

package/dist/exceptions/UnsupportedRelationException.d.ts

@@ -1,4 +1,4 @@
 export default class UnsupportedRelationException extends Error {
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(relation: string);
 }

package/dist/facades/App.d.ts

@@ -2,6 +2,7 @@ import { AppFacades, AppFacade, AppEvents } from '../types/App';
 import { default as Plugin } from '../contracts/Plugin';
 import { AppConfiguration } from '../types/Config';
 import { Unsubscribe } from 'nanoevents';
+import { Constructor } from '../types/Support';
 
 declare class App implements AppFacade {
     private facades;
@@ -13,19 +14,24 @@ declare class App implements AppFacade {
     bind<K extends keyof AppFacades>(key: K, facade: AppFacades[K]): void;
     plugins(): Plugin[];
     boot(configObject?: AppConfiguration): Promise<AppFacades>;
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    getPlugin<T extends Plugin>(abstract: Constructor<T>): T | undefined;
+    hasDebugModeEnabled(): boolean;
+    isLocal(): boolean;
+    isProduction(): boolean;
     on<E extends keyof AppEvents>(_: E, __: AppEvents[E]): Unsubscribe;
     once<E extends keyof AppEvents>(_: E, __: AppEvents[E]): void;
     emit<E extends keyof AppEvents>(_: E, __?: Omit<Parameters<AppEvents[E]>[0], 'source'>): void;
 }
 declare const _default: {
     new (...args: any[]): {
-        "__#1@#emitter": import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
+        emitter: import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
         "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
         on<E extends keyof AppEvents>(event: E, callback: AppEvents[E]): Unsubscribe;
         once<E_1 extends keyof AppEvents>(event: E_1, callback: AppEvents[E_1]): void;
         emit<E_2 extends keyof AppEvents>(event: E_2, data?: Omit<Parameters<AppEvents[E_2]>[0], "source">): void;
         [Symbol.toStringTag]: string;
     };
-    name: string;
 } & typeof App;
 export default _default;

package/dist/facades/Model.d.ts

@@ -7,7 +7,7 @@ import { Collection } from '../contracts/Collection';
 declare class ModelFacade implements ModelFacadeInterface {
     private readonly _schema;
     private _models;
-    static name: string;
+    [Symbol.toStringTag]: string;
     constructor(_schema: ModelSchema);
     boot(app: AppFacade): void;
     schema(): ModelSchema;
@@ -30,13 +30,12 @@ declare class ModelFacade implements ModelFacadeInterface {
 }
 declare const _default: {
     new (...args: any[]): {
-        "__#1@#emitter": import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
+        emitter: import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
         "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
         on<E extends keyof GlobalModelEvents>(event: E, callback: GlobalModelEvents[E]): Unsubscribe;
         once<E_1 extends keyof GlobalModelEvents>(event: E_1, callback: GlobalModelEvents[E_1]): void;
         emit<E_2 extends keyof GlobalModelEvents>(event: E_2, data?: Omit<Parameters<GlobalModelEvents[E_2]>[0], "source">): void;
         [Symbol.toStringTag]: string;
     };
-    name: string;
 } & typeof ModelFacade;
 export default _default;

package/dist/helpers/auth.d.ts

@@ -1 +1,3 @@
-export default function (): import('..').AuthFacade;
+import { AuthFacade } from '../types/Auth';
+
+export default function (): AuthFacade;

package/dist/mixins/BaseModel.d.ts

@@ -1,5 +1,5 @@
 import { BaseModel, Model as ModelInterface } from '../types/Model';
-import { AppFacades } from '../types/App';
+import { AppFacade, AppFacades } from '../types/App';
 
-export declare function BaseModelFactory(facades: AppFacades, abstract: string): typeof BaseModel;
+export declare function BaseModelFactory(app: AppFacade, abstract: string): typeof BaseModel;
 export declare function ModelFactory(facades: AppFacades, abstract: string, CustomModel: typeof BaseModel): typeof ModelInterface;

package/dist/mixins/HasEvents.d.ts

@@ -5,12 +5,11 @@ import { Constructor } from '../types/Support';
 export declare function isEventSource<T>(value: T): value is T & EventSource<any>;
 export declare function HasEvents<T extends EventSourceEvents, U extends Constructor>(Base: U): {
     new (...args: any[]): {
-        "__#1@#emitter": Emitter<EventSourceEvents>;
+        emitter: Emitter<EventSourceEvents>;
         "__#1@#createNanoEvents"(): Emitter<EventSourceEvents>;
         on<E extends keyof T>(event: E, callback: T[E]): import('nanoevents').Unsubscribe;
         once<E_1 extends keyof T>(event: E_1, callback: T[E_1]): void;
         emit<E_2 extends keyof T>(event: E_2, data?: Omit<Parameters<T[E_2]>[0], "source">): void;
         [Symbol.toStringTag]: string;
     };
-    name: string;
 } & U;

package/dist/types/App.d.ts

@@ -7,6 +7,7 @@ import { RouteFacade } from './Route';
 import { EventSource, Event } from './Event';
 import { ErrorFacade } from './Error';
 import { ReducibleInterface } from './Reducer';
+import { Constructor } from './Support';
 
 type Plugin = PluginInterface<AppFacade, AppFacades>;
 export type GlobalModelEvents = {
@@ -48,6 +49,12 @@ export type AppExternal = {
     make<T extends keyof AppFacades>(key: T): AppFacades[T];
     plugins: () => Plugin[];
     on: EventSource<AppEvents>['once'];
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    getPlugin<T extends Plugin>(abstract: Constructor<T>): T | undefined;
+    hasDebugModeEnabled(): boolean;
+    isLocal(): boolean;
+    isProduction(): boolean;
 };
 export type AppFacade = AppExternal & {
     has(key: string): boolean;

package/dist/types/Builder.d.ts

@@ -12,6 +12,9 @@ export type BuilderInterface<R, C> = EventSource<BuilderEventMap<R, C>> & {
     where(key: string, value: JsonValue): BuilderInterface<R, C>;
     where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface<R, C>;
     where(key: string | Scope<R, C>, operatorOrValue?: ExtendedOperator | JsonValue, value?: JsonValue): BuilderInterface<R, C>;
+    with(relation: string | string[]): BuilderInterface<R, C>;
+    withOnly(relation: string | string[]): BuilderInterface<R, C>;
+    without(relation: string | string[]): BuilderInterface<R, C>;
     whereNull(key: string): BuilderInterface<R, C>;
     whereNotNull(key: string): BuilderInterface<R, C>;
     whereBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<R, C>;
@@ -20,6 +23,7 @@ export type BuilderInterface<R, C> = EventSource<BuilderEventMap<R, C>> & {
     searchBy(term: string): BuilderInterface<R, C>;
     minified(): BuilderInterface<R, C>;
     limit(value: number): BuilderInterface<R, C>;
+    include(searchParams: URLSearchParams): BuilderInterface<R, C>;
     get(page?: number, replaceLinksWith?: string): Promise<C>;
     all(): Promise<Collection<R>>;
     first(): Promise<R | null>;

package/dist/types/Model.d.ts

@@ -3,6 +3,7 @@ import { EventSource, Event } from './Event';
 import { Collection } from './Collection';
 import { RelationInterface, BuilderInterface, Scope, ExtendedOperator } from './Relation';
 import { JsonObject, JsonValue } from './Support';
+import { RouteGenerator } from './Route';
 
 export type RelationRepository = Record<string, RelationInterface<Model, ModelPaginatedResponse>>;
 export type ModelEvents = {
@@ -45,18 +46,25 @@ export declare class BaseModel implements EventSource<ModelEvents> {
     setAttribute(key: string, value: unknown): void;
     getKey(): string | number;
     getKeyName(): string;
-    fill(attributes: JsonObject): void;
+    fill(attributes: object): void;
     toJson(): JsonObject;
     diff(): JsonObject;
     getType(): string;
     dump(): void;
-    save(options?: ModelSaveOptions): Promise<AxiosResponse<unknown, unknown>>;
+    save(options?: ModelSaveOptions): Promise<AxiosResponse | void>;
     update(attributes: JsonObject): Promise<void>;
-    delete(): Promise<AxiosResponse<unknown, unknown>>;
-    forceDelete(): Promise<AxiosResponse<unknown, unknown>>;
-    restore(): Promise<AxiosResponse<unknown, unknown>>;
+    delete(): Promise<AxiosResponse>;
+    forceDelete(): Promise<AxiosResponse>;
+    restore(): Promise<AxiosResponse>;
     refresh(): Promise<void>;
     relation(relationName: string): RelationInterface<Model, ModelPaginatedResponse> | undefined;
+    getErrorBag(method: string): string;
+    getRouteForSave(): RouteGenerator;
+    getRouteForUpdate(): RouteGenerator;
+    getRouteForDelete(): RouteGenerator;
+    getRouteForRestore(): RouteGenerator;
+    getRouteForForceDelete(): RouteGenerator;
+    getRouteForRefresh(): RouteGenerator;
     static getSchemaName(): string;
     static getSchema(): ModelSchemaAttributes;
     static query(): BuilderInterface<Model, ModelPaginatedResponse>;
@@ -91,7 +99,7 @@ export declare class BaseModel implements EventSource<ModelEvents> {
 }
 export declare class Model extends BaseModel {
     [key: string]: any;
-    static [key: string]: any;
+    [Symbol.toStringTag]: string;
 }
 export interface ModelSaveOptions {
     additionalPayload?: object;
@@ -107,6 +115,21 @@ export interface ModelTableColumnDefinition {
     sortable?: boolean;
 }
 export interface ModelSchemaAttributes {
+    attributes: {
+        appended: true | null;
+        cast: string | null;
+        default: string | null;
+        fillable: boolean;
+        hidden: boolean;
+        increments: boolean;
+        name: string;
+        nullable: boolean;
+        phpType: string | null;
+        primary: boolean;
+        type: string | null;
+        unique: boolean;
+        virtual: boolean;
+    }[];
     displayName: {
         singular: string;
         plural: string;
@@ -117,6 +140,7 @@ export interface ModelSchemaAttributes {
     primaryKey: string;
     timestamps: boolean;
     labeledBy: string;
+    [key: string]: any;
 }
 export interface RelationMetaData {
     model: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminix/core",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.10",
   "description": "> Projeto em desenvolvimento",
   "main": "dist/core.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,8 @@
     "lint:fix": "eslint ./src ./tests --ext .ts --fix",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "ci": "npm run lint && npm run test"
+    "ci": "npm run lint && npm run test",
+    "publish:beta": "npm run build && npm publish --tag beta"
   },
   "author": "",
   "license": "MIT",

package/vite.config.js

@@ -3,6 +3,8 @@ import { resolve } from 'path';
 
 import dts from 'vite-plugin-dts';
 
+import packageJson from './package.json';
+
 export default defineConfig({
     plugins: [dts({ insertTypesEntry: true })],
     build: {
@@ -11,7 +13,7 @@ export default defineConfig({
             formats: ['es']
         },
         rollupOptions: {
-            external: ['axios', 'lodash', 'immer']
+            external: Object.keys(packageJson.peerDependencies),
         }
     },