@aerogel/core 0.0.0-next.926bde19326fe7b6b24b277666936862b64d8295 → 0.0.0-next.b85327579d32f21c6a9fa21142f0165cdd320d7e

package/src/errors/Errors.ts

@@ -0,0 +1,132 @@
+import { JSError, facade, isObject } from '@noeldemartin/utils';
+
+import App from '@/services/App';
+import ServiceBootError from '@/errors/ServiceBootError';
+import UI from '@/ui/UI';
+import { translate } from '@/lang/utils';
+
+import Service from './Errors.state';
+import type { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
+
+export class ErrorsService extends Service {
+
+    public forceReporting: boolean = false;
+    private enabled: boolean = true;
+
+    public enable(): void {
+        this.enabled = true;
+    }
+
+    public disable(): void {
+        this.enabled = false;
+    }
+
+    public async inspect(error: ErrorSource | ErrorReport[]): Promise<void> {
+        const reports = Array.isArray(error) ? error : [await this.createErrorReport(error)];
+
+        // TODO open errors modal
+        reports;
+    }
+
+    public async report(error: ErrorSource, message?: string): Promise<void> {
+        if (App.isDevelopment || App.isTesting) {
+            this.logError(error);
+        }
+
+        if (!this.enabled) {
+            throw error;
+        }
+
+        if (!App.isMounted) {
+            const startupError = await this.createStartupErrorReport(error);
+
+            if (startupError) {
+                this.setState({ startupErrors: this.startupErrors.concat(startupError) });
+            }
+
+            return;
+        }
+
+        const report = await this.createErrorReport(error);
+        const log: ErrorReportLog = {
+            report,
+            seen: false,
+            date: new Date(),
+        };
+
+        // TODO open error snackbar
+        UI.alert(message ?? 'Something went wrong, but it\'s not your fault! (look at the console for details)');
+
+        this.setState({ logs: [log].concat(this.logs) });
+    }
+
+    public see(report: ErrorReport): void {
+        this.setState({
+            logs: this.logs.map((log) => {
+                if (log.report !== report) {
+                    return log;
+                }
+
+                return {
+                    ...log,
+                    seen: true,
+                };
+            }),
+        });
+    }
+
+    public seeAll(): void {
+        this.setState({
+            logs: this.logs.map((log) => ({
+                ...log,
+                seen: true,
+            })),
+        });
+    }
+
+    private logError(error: unknown): void {
+        // eslint-disable-next-line no-console
+        console.error(error);
+
+        if (isObject(error) && error.cause) {
+            this.logError(error.cause);
+        }
+    }
+
+    private async createErrorReport(error: ErrorSource): Promise<ErrorReport> {
+        if (typeof error === 'string') {
+            return { title: error };
+        }
+
+        if (error instanceof Error || error instanceof JSError) {
+            return this.createErrorReportFromError(error);
+        }
+
+        return {
+            title: translate('errors.unknown'),
+            error,
+        };
+    }
+
+    private async createStartupErrorReport(error: ErrorSource): Promise<ErrorReport | null> {
+        if (error instanceof ServiceBootError) {
+            // Ignore second-order boot errors in order to have a cleaner startup crash screen.
+            return error.cause instanceof ServiceBootError ? null : this.createErrorReport(error.cause);
+        }
+
+        return this.createErrorReport(error);
+    }
+
+    private createErrorReportFromError(error: Error | JSError, defaults: Partial<ErrorReport> = {}): ErrorReport {
+        return {
+            title: error.name,
+            description: error.message,
+            details: error.stack,
+            error,
+            ...defaults,
+        };
+    }
+
+}
+
+export default facade(new ErrorsService());

package/src/errors/index.ts

@@ -0,0 +1,21 @@
+import { bootServices } from '@/services';
+import { definePlugin } from '@/plugins';
+
+import Errors from './Errors';
+import { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
+
+export { Errors, ErrorSource, ErrorReport, ErrorReportLog };
+
+const services = { $errors: Errors };
+
+export type ErrorsServices = typeof services;
+
+export default definePlugin({
+    async install(app) {
+        await bootServices(app, services);
+    },
+});
+
+declare module '@/services' {
+    export interface Services extends ErrorsServices {}
+}

package/src/forms/Form.ts

@@ -6,6 +6,7 @@ import type { ComputedRef, DeepReadonly, Ref, UnwrapNestedRefs } from 'vue';
 export const FormFieldTypes = {
     String: 'string',
     Number: 'number',
+    Boolean: 'boolean',
 } as const;
 
 export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
@@ -33,6 +34,8 @@ export type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.Strin
     ? string
     : TType extends typeof FormFieldTypes.Number
     ? number
+    : TType extends typeof FormFieldTypes.Boolean
+    ? boolean
     : never;
 
 export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
@@ -78,10 +81,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
     }
 
     public validate(): boolean {
-        const errors = Object.entries(this._fields).reduce((errors, [name, definition]) => {
-            errors[name] = this.getFieldErrors(name, definition);
+        const errors = Object.entries(this._fields).reduce((formErrors, [name, definition]) => {
+            formErrors[name] = this.getFieldErrors(name, definition);
 
-            return errors;
+            return formErrors;
         }, {} as Record<string, string[] | null>);
 
         this.resetErrors(errors);
@@ -135,10 +138,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
             return {} as FormData<Fields>;
         }
 
-        const data = Object.entries(fields).reduce((data, [name, definition]) => {
-            data[name as keyof Fields] = (definition.default ?? null) as FormData<Fields>[keyof Fields];
+        const data = Object.entries(fields).reduce((formData, [name, definition]) => {
+            formData[name as keyof Fields] = (definition.default ?? null) as FormData<Fields>[keyof Fields];
 
-            return data;
+            return formData;
         }, {} as FormData<Fields>);
 
         return reactive(data) as FormData<Fields>;
@@ -149,10 +152,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
             return {} as FormErrors<Fields>;
         }
 
-        const errors = Object.keys(fields).reduce((errors, name) => {
-            errors[name as keyof Fields] = null;
+        const errors = Object.keys(fields).reduce((formErrors, name) => {
+            formErrors[name as keyof Fields] = null;
 
-            return errors;
+            return formErrors;
         }, {} as FormErrors<Fields>);
 
         return reactive(errors) as FormErrors<Fields>;

package/src/forms/utils.ts

@@ -1,6 +1,23 @@
 import { FormFieldTypes } from './Form';
 import type { FormFieldDefinition } from './Form';
 
+export function booleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Boolean,
+    };
+}
+
+export function requiredBooleanInput(
+    defaultValue?: boolean,
+): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Boolean,
+        rules: 'required',
+    };
+}
+
 export function requiredNumberInput(
     defaultValue?: number,
 ): FormFieldDefinition<typeof FormFieldTypes.Number, 'required'> {

package/src/lang/Lang.ts

@@ -1,4 +1,4 @@
-import { facade } from '@noeldemartin/utils';
+import { facade, toString } from '@noeldemartin/utils';
 
 import App from '@/services/App';
 import Service from '@/services/Service';
@@ -41,10 +41,18 @@ export class LangService extends Service {
     ): string {
         defaultMessage ??= defaultMessageOrParameters as string;
 
-        const parameters = typeof defaultMessageOrParameters === 'string' ? {} : defaultMessageOrParameters;
+        const parameters = typeof defaultMessageOrParameters === 'string' ? {} : defaultMessageOrParameters ?? {};
         const message = this.provider.translate(key, parameters) ?? key;
 
-        return message === key ? defaultMessage : message;
+        if (message === key) {
+            return Object.entries(parameters).reduce(
+                (renderedMessage, [name, value]) =>
+                    renderedMessage.replace(new RegExp(`\\{\\s*${name}\\s*\\}`, 'g'), toString(value)),
+                defaultMessage,
+            );
+        }
+
+        return message;
     }
 
 }

package/src/lang/index.ts

@@ -2,16 +2,14 @@ import { bootServices } from '@/services';
 import { definePlugin } from '@/plugins';
 
 import Lang, { LangProvider } from './Lang';
+import { translate, translateWithDefault } from './utils';
 
-export { Lang, LangProvider };
+export { Lang, LangProvider, translate, translateWithDefault };
 
 const services = { $lang: Lang };
 
 export type LangServices = typeof services;
 
-export const translate = Lang.translate.bind(Lang);
-export const translateWithDefault = Lang.translateWithDefault.bind(Lang);
-
 export default definePlugin({
     async install(app) {
         app.config.globalProperties.$t ??= translate;
@@ -22,7 +20,7 @@ export default definePlugin({
 });
 
 declare module '@/services' {
-    interface Services extends LangServices {}
+    export interface Services extends LangServices {}
 }
 
 declare module '@vue/runtime-core' {

package/src/lang/utils.ts

@@ -0,0 +1,4 @@
+import Lang from './Lang';
+
+export const translate = Lang.translate.bind(Lang);
+export const translateWithDefault = Lang.translateWithDefault.bind(Lang);

package/src/main.ts

@@ -2,6 +2,7 @@ import './globals';
 
 export * from './bootstrap';
 export * from './components';
+export * from './errors';
 export * from './forms';
 export * from './lang';
 export * from './plugins';

package/src/services/App.state.ts

@@ -1,10 +1,13 @@
 import { defineServiceState } from '@/services/Service';
 
 export default defineServiceState({
+    name: 'app',
     initialState: {
         environment: __AG_ENV,
+        isMounted: false,
     },
     computed: {
         isDevelopment: (state) => state.environment === 'development',
+        isTesting: (state) => state.environment === 'testing',
     },
 });

package/src/services/App.ts

@@ -1,7 +1,17 @@
 import { facade } from '@noeldemartin/utils';
 
+import Events from '@/services/Events';
+
 import Service from './App.state';
 
-export class AppService extends Service {}
+export class AppService extends Service {
+
+    protected async boot(): Promise<void> {
+        await super.boot();
+
+        Events.once('application-mounted', () => this.setState({ isMounted: true }));
+    }
+
+}
 
 export default facade(new AppService());

package/src/services/Service.ts

@@ -1,27 +1,42 @@
-import { computed, reactive } from 'vue';
-import { MagicObject, PromisedValue } from '@noeldemartin/utils';
-import type { ComputedRef } from 'vue';
+import { MagicObject, PromisedValue, Storage, isEmpty, objectDeepClone, objectOnly } from '@noeldemartin/utils';
 import type { Constructor } from '@noeldemartin/utils';
+import type { Store } from 'pinia';
 
 import ServiceBootError from '@/errors/ServiceBootError';
+import { defineServiceStore } from '@/services/store';
 
 export type ServiceState = Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-export type DefaultServiceState = {};
+export type DefaultServiceState = any; // eslint-disable-line @typescript-eslint/no-explicit-any
 export type ServiceConstructor<T extends Service = Service> = Constructor<T> & typeof Service;
 
 export type ComputedStateDefinition<TState extends ServiceState, TComputedState extends ServiceState> = {
     [K in keyof TComputedState]: (state: TState) => TComputedState[K];
-};
+} & ThisType<{
+    readonly [K in keyof TComputedState]: TComputedState[K];
+}>;
 
 export function defineServiceState<
     State extends ServiceState = ServiceState,
     ComputedState extends ServiceState = {}
 >(options: {
+    name: string;
     initialState: State;
+    persist?: (keyof State)[];
     computed?: ComputedStateDefinition<State, ComputedState>;
-}): Constructor<State> & Constructor<ComputedState> & ServiceConstructor {
+    serialize?: (state: Partial<State>) => Partial<State>;
+}): Constructor<State> & Constructor<ComputedState> & Constructor<Service<State, ComputedState, Partial<State>>> {
     return class extends Service<State, ComputedState> {
 
+        public static persist = (options.persist as string[]) ?? [];
+
+        protected usesStore(): boolean {
+            return true;
+        }
+
+        protected getName(): string | null {
+            return options.name ?? null;
+        }
+
         protected getInitialState(): State {
             return options.initialState;
         }
@@ -29,44 +44,53 @@ export function defineServiceState<
         protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState> {
             return options.computed ?? ({} as ComputedStateDefinition<State, ComputedState>);
         }
+
+        protected serializePersistedState(state: Partial<State>): Partial<State> {
+            return options.serialize?.(state) ?? state;
+        }
     
-    } as unknown as Constructor<State> & Constructor<ComputedState> & ServiceConstructor;
+    } as unknown as Constructor<State> &
+        Constructor<ComputedState> &
+        Constructor<Service<State, ComputedState, Partial<State>>>;
 }
 
 export default class Service<
     State extends ServiceState = DefaultServiceState,
-    ComputedState extends ServiceState = {}
+    ComputedState extends ServiceState = {},
+    ServiceStorage extends Partial<State> = Partial<State>
 > extends MagicObject {
 
-    protected _namespace: string;
+    public static persist: string[] = [];
+
+    protected _name: string;
     private _booted: PromisedValue<void>;
-    private _state: State;
-    private _computedState: Record<keyof ComputedState, ComputedRef>;
+    private _computedStateKeys: Set<keyof State>;
+    private _store?: Store | false;
 
     constructor() {
         super();
 
-        this._namespace = new.target.name;
-        this._booted = new PromisedValue();
-        this._state = reactive(this.getInitialState());
-        this._computedState = Object.entries(this.getComputedStateDefinition()).reduce(
-            (computedState, [name, method]) => {
-                computedState[name as keyof ComputedState] = computed(() => method(this._state));
+        const getters = this.getComputedStateDefinition();
 
-                return computedState;
-            },
-            {} as Record<keyof ComputedState, ComputedRef>,
-        );
+        this._name = this.getName() ?? new.target.name;
+        this._booted = new PromisedValue();
+        this._computedStateKeys = new Set(Object.keys(getters));
+        this._store =
+            this.usesStore() &&
+            defineServiceStore(this._name, {
+                state: () => this.getInitialState(),
+
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                getters: getters as any,
+            });
     }
 
     public get booted(): PromisedValue<void> {
         return this._booted;
     }
 
-    public launch(namespace?: string): Promise<void> {
-        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._namespace, error));
-
-        this._namespace = namespace ?? this._namespace;
+    public launch(): Promise<void> {
+        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._name, error));
 
         try {
             this.boot()
@@ -79,15 +103,48 @@ export default class Service<
         return this._booted;
     }
 
+    public hasState<P extends keyof State>(property: P): boolean {
+        if (!this._store) {
+            return false;
+        }
+
+        return property in this._store.$state || this._computedStateKeys.has(property);
+    }
+
+    public getState(): State;
+    public getState<P extends keyof State>(property: P): State[P];
+    public getState<P extends keyof State>(property?: P): State | State[P] {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const store = this._store as any;
+
+        if (property) {
+            return store ? store[property] : undefined;
+        }
+
+        return store ? store : {};
+    }
+
+    public setState<P extends keyof State>(property: P, value: State[P]): void;
+    public setState(state: Partial<State>): void;
+    public setState<P extends keyof State>(stateOrProperty: P | Partial<State>, value?: State[P]): void {
+        if (!this._store) {
+            return;
+        }
+
+        const state = (
+            typeof stateOrProperty === 'string' ? { [stateOrProperty]: value } : stateOrProperty
+        ) as Partial<State>;
+
+        Object.assign(this._store.$state, state);
+
+        this.onStateUpdated(state);
+    }
+
     protected __get(property: string): unknown {
         if (this.hasState(property)) {
             return this.getState(property);
         }
 
-        if (this.hasComputedState(property)) {
-            return this.getComputedState(property);
-        }
-
         return super.__get(property);
     }
 
@@ -95,26 +152,29 @@ export default class Service<
         this.setState({ [property]: value } as Partial<State>);
     }
 
-    protected hasState<P extends keyof State>(property: P): boolean {
-        return property in this._state;
-    }
+    protected onStateUpdated(state: Partial<State>): void {
+        // TODO fix this.static()
+        const persist = (this.constructor as unknown as { persist: string[] }).persist;
+        const persisted = objectOnly(state, persist);
 
-    protected hasComputedState<P extends keyof State>(property: P): boolean {
-        return property in this._computedState;
-    }
+        if (isEmpty(persisted)) {
+            return;
+        }
+
+        const storage = Storage.require<ServiceStorage>(this._name);
 
-    protected getState(): State;
-    protected getState<P extends keyof State>(property: P): State[P];
-    protected getState<P extends keyof State>(property?: P): State | State[P] {
-        return property ? this._state[property] : this._state;
+        Storage.set(this._name, {
+            ...storage,
+            ...this.serializePersistedState(objectDeepClone(persisted) as Partial<State>),
+        });
     }
 
-    protected getComputedState<P extends keyof ComputedState>(property: P): ComputedState[P] {
-        return this._computedState[property]?.value;
+    protected usesStore(): boolean {
+        return false;
     }
 
-    protected setState(state: Partial<State>): void {
-        Object.assign(this._state, state);
+    protected getName(): string | null {
+        return null;
     }
 
     protected getInitialState(): State {
@@ -125,8 +185,30 @@ export default class Service<
         return {} as ComputedStateDefinition<State, ComputedState>;
     }
 
+    protected serializePersistedState(state: Partial<State>): Partial<State> {
+        return state;
+    }
+
     protected async boot(): Promise<void> {
-        //
+        this.restorePersistedState();
+    }
+
+    protected restorePersistedState(): void {
+        // TODO fix this.static()
+        const persist = (this.constructor as unknown as { persist: string[] }).persist;
+
+        if (!this.usesStore() || isEmpty(persist)) {
+            return;
+        }
+
+        if (Storage.has(this._name)) {
+            const persisted = Storage.require<ServiceStorage>(this._name);
+            this.setState(persisted);
+
+            return;
+        }
+
+        Storage.set(this._name, objectOnly(this.getState(), persist));
     }
 
 }

package/src/services/index.ts

@@ -5,6 +5,7 @@ import { definePlugin } from '@/plugins';
 import App from './App';
 import Events from './Events';
 import Service from './Service';
+import { getPiniaStore } from './store';
 
 export * from './App';
 export * from './Events';
@@ -23,9 +24,9 @@ export interface Services extends DefaultServices {}
 
 export async function bootServices(app: VueApp, services: Record<string, Service>): Promise<void> {
     await Promise.all(
-        Object.entries(services).map(async ([name, service]) => {
+        Object.entries(services).map(async ([_, service]) => {
             // eslint-disable-next-line no-console
-            await service.launch(name.slice(1)).catch((error) => console.error(error));
+            await service.launch().catch((error) => console.error(error));
         }),
     );
 
@@ -33,11 +34,24 @@ export async function bootServices(app: VueApp, services: Record<string, Service
 }
 
 export default definePlugin({
-    async install(app) {
-        await bootServices(app, defaultServices);
+    async install(app, options) {
+        const services = {
+            ...defaultServices,
+            ...options.services,
+        };
+
+        app.use(getPiniaStore());
+
+        await bootServices(app, services);
     },
 });
 
+declare module '@/bootstrap/options' {
+    interface AerogelOptions {
+        services?: Record<string, Service>;
+    }
+}
+
 declare module '@vue/runtime-core' {
     interface ComponentCustomProperties extends Services {}
 }

package/src/services/store.ts

@@ -0,0 +1,27 @@
+import { createPinia, defineStore, setActivePinia } from 'pinia';
+import type { DefineStoreOptions, Pinia, StateTree, Store, _GettersTree } from 'pinia';
+
+let _store: Pinia | null = null;
+
+function initializePiniaStore(): Pinia {
+    if (!_store) {
+        _store = createPinia();
+
+        setActivePinia(_store);
+    }
+
+    return _store;
+}
+
+export function getPiniaStore(): Pinia {
+    return _store ?? initializePiniaStore();
+}
+
+export function defineServiceStore<Id extends string, S extends StateTree = {}, G extends _GettersTree<S> = {}, A = {}>(
+    name: Id,
+    options: Omit<DefineStoreOptions<Id, S, G, A>, 'id'>,
+): Store<Id, S, G, A> {
+    initializePiniaStore();
+
+    return defineStore(name, options)();
+}

package/src/ui/UI.state.ts

@@ -18,5 +18,6 @@ export interface ModalComponent<
 > {}
 
 export default defineServiceState({
+    name: 'ui',
     initialState: { modals: [] as Modal[] },
 });