@raubjo/architect-core 0.1.0 → 0.1.2

package/src/storage/manager.ts

@@ -2,77 +2,81 @@ import type ConfigRepository from "../config/repository";
 import IndexedDbAdapter from "./adapters/indexed-db";
 import LocalStorageAdapter from "./adapters/local-storage";
 import MemoryStorageAdapter from "./adapters/memory";
-import type { StorageAdapter } from "./storage";
+import type { Adapter } from "./adapters/contract";
 
 type DriverName = "memory" | "local" | "indexed";
 
-export default class StorageManager implements StorageAdapter {
-  protected adapters: Record<string, StorageAdapter>;
-  protected active: string;
-
-  constructor(adapters: Record<string, StorageAdapter>, active: string = "memory") {
-    this.adapters = adapters;
-    this.active = active in this.adapters ? active : "memory";
-  }
-
-  static fromConfig(config: ConfigRepository): StorageManager {
-    const adapters = StorageManager.defaultAdapters();
-    const driver = config.string("storage.driver", "memory");
-
-    return new StorageManager(adapters, driver);
-  }
-
-  static defaultAdapters(): Record<DriverName, StorageAdapter> {
-    const memory = new MemoryStorageAdapter();
-    const hasWindow = typeof window !== "undefined";
-    const hasLocal = hasWindow && typeof window.localStorage !== "undefined";
-    const hasIndexed = typeof globalThis.indexedDB !== "undefined";
-
-    return {
-      memory,
-      local: hasLocal ? new LocalStorageAdapter(window.localStorage) : memory,
-      indexed: hasIndexed ? new IndexedDbAdapter() : memory,
-    };
-  }
-
-  drv(name?: string): StorageAdapter {
-    if (typeof name === "string") {
-      if (!(name in this.adapters)) {
-        throw new Error(`Storage driver [${name}] is not defined.`);
-      }
-
-      return this.adapters[name];
+export default class StorageManager implements Adapter {
+    protected adapters: Record<string, Adapter>;
+    protected active: string;
+
+    constructor(adapters: Record<string, Adapter>, active: string = "memory") {
+        this.adapters = adapters;
+        this.active = active in this.adapters ? active : "memory";
+    }
+
+    static fromConfig(config: ConfigRepository): StorageManager {
+        const adapters = StorageManager.defaultAdapters();
+        const driver = config.string("storage.driver", "memory");
+
+        return new StorageManager(adapters, driver);
     }
 
-    return this.adapters[this.active];
-  }
+    static defaultAdapters(): Record<DriverName, Adapter> {
+        const memory = new MemoryStorageAdapter();
+        const hasWindow = typeof window !== "undefined";
+        const hasLocal =
+            hasWindow && typeof window.localStorage !== "undefined";
+        const hasIndexed = typeof globalThis.indexedDB !== "undefined";
+
+        return {
+            memory,
+            local:
+                hasLocal ?
+                    new LocalStorageAdapter(window.localStorage)
+                :   memory,
+            indexed: hasIndexed ? new IndexedDbAdapter() : memory,
+        };
+    }
+
+    drv(name?: string): Adapter {
+        if (typeof name === "string") {
+            if (!(name in this.adapters)) {
+                throw new Error(`Storage driver [${name}] is not defined.`);
+            }
+
+            return this.adapters[name];
+        }
+
+        return this.adapters[this.active];
+    }
 
-  use(name: string): this {
-    this.active = this.drv(name) ? name : this.active;
-    return this;
-  }
+    use(name: string): this {
+        this.active = this.drv(name) ? name : this.active;
+        return this;
+    }
 
-  get<T = unknown>(key: string): Promise<T | null> {
-    return this.drv().get<T>(key);
-  }
+    get<T = unknown>(key: string): Promise<T | null> {
+        return this.drv().get<T>(key);
+    }
 
-  set<T = unknown>(key: string, value: T): Promise<void> {
-    return this.drv().set<T>(key, value);
-  }
+    set<T = unknown>(key: string, value: T): Promise<void> {
+        return this.drv().set<T>(key, value);
+    }
 
-  has(key: string): Promise<boolean> {
-    return this.drv().has(key);
-  }
+    has(key: string): Promise<boolean> {
+        return this.drv().has(key);
+    }
 
-  delete(key: string): Promise<void> {
-    return this.drv().delete(key);
-  }
+    delete(key: string): Promise<void> {
+        return this.drv().delete(key);
+    }
 
-  clear(): Promise<void> {
-    return this.drv().clear();
-  }
+    clear(): Promise<void> {
+        return this.drv().clear();
+    }
 
-  keys(): Promise<string[]> {
-    return this.drv().keys();
-  }
+    keys(): Promise<string[]> {
+        return this.drv().keys();
+    }
 }

package/src/storage/storage.ts

@@ -1,8 +1 @@
-export interface StorageAdapter {
-  get<T = unknown>(key: string): Promise<T | null>;
-  set<T = unknown>(key: string, value: T): Promise<void>;
-  has(key: string): Promise<boolean>;
-  delete(key: string): Promise<void>;
-  clear(): Promise<void>;
-  keys(): Promise<string[]>;
-}
+export type { Adapter as StorageAdapter, Contract } from "./adapters/contract";

package/src/support/facades/cache.ts

@@ -3,44 +3,44 @@ import type { CacheStore } from "../../cache/cache";
 import Facade from "./facade";
 
 export default class Cache extends Facade {
-  private constructor() {
-    super();
-  }
-
-  protected static getFacadeAccessor(): string {
-    return "cache";
-  }
-
-  static store(name?: string): CacheStore {
-    return this.resolveFacadeInstance<CacheManager>().store(name);
-  }
-
-  static use(name: string): Cache {
-    this.resolveFacadeInstance<CacheManager>().use(name);
-    return this;
-  }
-
-  static get<T = unknown>(key: string): Promise<T | null> {
-    return this.resolveFacadeInstance<CacheManager>().get<T>(key);
-  }
-
-  static set<T = unknown>(key: string, value: T): Promise<void> {
-    return this.resolveFacadeInstance<CacheManager>().set<T>(key, value);
-  }
-
-  static has(key: string): Promise<boolean> {
-    return this.resolveFacadeInstance<CacheManager>().has(key);
-  }
-
-  static delete(key: string): Promise<void> {
-    return this.resolveFacadeInstance<CacheManager>().delete(key);
-  }
-
-  static clear(): Promise<void> {
-    return this.resolveFacadeInstance<CacheManager>().clear();
-  }
-
-  static keys(): Promise<string[]> {
-    return this.resolveFacadeInstance<CacheManager>().keys();
-  }
+    private constructor() {
+        super();
+    }
+
+    protected static getFacadeAccessor(): string {
+        return "cache";
+    }
+
+    static store(name?: string): CacheStore {
+        return this.resolveFacadeInstance<CacheManager>().store(name);
+    }
+
+    static use(name: string): Cache {
+        this.resolveFacadeInstance<CacheManager>().use(name);
+        return this;
+    }
+
+    static get<T = unknown>(key: string): Promise<T | null> {
+        return this.resolveFacadeInstance<CacheManager>().get<T>(key);
+    }
+
+    static set<T = unknown>(key: string, value: T): Promise<void> {
+        return this.resolveFacadeInstance<CacheManager>().set<T>(key, value);
+    }
+
+    static has(key: string): Promise<boolean> {
+        return this.resolveFacadeInstance<CacheManager>().has(key);
+    }
+
+    static delete(key: string): Promise<void> {
+        return this.resolveFacadeInstance<CacheManager>().delete(key);
+    }
+
+    static clear(): Promise<void> {
+        return this.resolveFacadeInstance<CacheManager>().clear();
+    }
+
+    static keys(): Promise<string[]> {
+        return this.resolveFacadeInstance<CacheManager>().keys();
+    }
 }

package/src/support/facades/config.ts

@@ -3,65 +3,95 @@ import type { ConfigDefaults, ConfigItems } from "../../config/repository";
 import Facade from "./facade";
 
 export default class Config extends Facade {
-  private constructor() {
-    super();
-  }
+    private constructor() {
+        super();
+    }
 
-  protected static getFacadeAccessor(): string {
-    return "config";
-  }
+    protected static getFacadeAccessor(): string {
+        return "config";
+    }
 
-  static has(key: string | string[]): boolean {
-    return this.resolveFacadeInstance<ConfigRepository>().has(key);
-  }
+    static has(key: string | string[]): boolean {
+        return this.resolveFacadeInstance<ConfigRepository>().has(key);
+    }
 
-  static get<T = unknown>(
-    key: string | string[],
-    defaultValue: T | (() => T) | null = null,
-  ): T | Record<string, unknown> | null {
-    return this.resolveFacadeInstance<ConfigRepository>().get<T>(key, defaultValue);
-  }
+    static get<T = unknown>(
+        key: string | string[],
+        defaultValue: T | (() => T) | null = null,
+    ): T | Record<string, unknown> | null {
+        return this.resolveFacadeInstance<ConfigRepository>().get<T>(
+            key,
+            defaultValue,
+        );
+    }
 
-  static getMany(keys: string[] | ConfigDefaults): Record<string, unknown> {
-    return this.resolveFacadeInstance<ConfigRepository>().getMany(keys);
-  }
+    static getMany(keys: string[] | ConfigDefaults): Record<string, unknown> {
+        return this.resolveFacadeInstance<ConfigRepository>().getMany(keys);
+    }
 
-  static string(key: string, defaultValue: string | (() => string) | null = null): string {
-    return this.resolveFacadeInstance<ConfigRepository>().string(key, defaultValue);
-  }
+    static string(
+        key: string,
+        defaultValue: string | (() => string) | null = null,
+    ): string {
+        return this.resolveFacadeInstance<ConfigRepository>().string(
+            key,
+            defaultValue,
+        );
+    }
 
-  static integer(key: string, defaultValue: number | (() => number) | null = null): number {
-    return this.resolveFacadeInstance<ConfigRepository>().integer(key, defaultValue);
-  }
+    static integer(
+        key: string,
+        defaultValue: number | (() => number) | null = null,
+    ): number {
+        return this.resolveFacadeInstance<ConfigRepository>().integer(
+            key,
+            defaultValue,
+        );
+    }
 
-  static float(key: string, defaultValue: number | (() => number) | null = null): number {
-    return this.resolveFacadeInstance<ConfigRepository>().float(key, defaultValue);
-  }
+    static float(
+        key: string,
+        defaultValue: number | (() => number) | null = null,
+    ): number {
+        return this.resolveFacadeInstance<ConfigRepository>().float(
+            key,
+            defaultValue,
+        );
+    }
 
-  static boolean(
-    key: string,
-    defaultValue: boolean | (() => boolean) | null = null,
-  ): boolean {
-    return this.resolveFacadeInstance<ConfigRepository>().boolean(key, defaultValue);
-  }
+    static boolean(
+        key: string,
+        defaultValue: boolean | (() => boolean) | null = null,
+    ): boolean {
+        return this.resolveFacadeInstance<ConfigRepository>().boolean(
+            key,
+            defaultValue,
+        );
+    }
 
-  static array<T = unknown>(key: string, defaultValue: T[] | (() => T[]) | null = null): T[] {
-    return this.resolveFacadeInstance<ConfigRepository>().array<T>(key, defaultValue);
-  }
+    static array<T = unknown>(
+        key: string,
+        defaultValue: T[] | (() => T[]) | null = null,
+    ): T[] {
+        return this.resolveFacadeInstance<ConfigRepository>().array<T>(
+            key,
+            defaultValue,
+        );
+    }
 
-  static set(key: string | ConfigItems, value: unknown = null): void {
-    this.resolveFacadeInstance<ConfigRepository>().set(key, value);
-  }
+    static set(key: string | ConfigItems, value: unknown = null): void {
+        this.resolveFacadeInstance<ConfigRepository>().set(key, value);
+    }
 
-  static prepend(key: string, value: unknown): void {
-    this.resolveFacadeInstance<ConfigRepository>().prepend(key, value);
-  }
+    static prepend(key: string, value: unknown): void {
+        this.resolveFacadeInstance<ConfigRepository>().prepend(key, value);
+    }
 
-  static push(key: string, value: unknown): void {
-    this.resolveFacadeInstance<ConfigRepository>().push(key, value);
-  }
+    static push(key: string, value: unknown): void {
+        this.resolveFacadeInstance<ConfigRepository>().push(key, value);
+    }
 
-  static all(): ConfigItems {
-    return this.resolveFacadeInstance<ConfigRepository>().all();
-  }
+    static all(): ConfigItems {
+        return this.resolveFacadeInstance<ConfigRepository>().all();
+    }
 }

package/src/support/facades/facade.ts

@@ -1,42 +1,57 @@
 import { Application } from "../../foundation/application";
 
 export default abstract class Facade {
-  protected static resolvedInstance = new Map<Parameters<typeof Application.make>[0], unknown>();
+    protected static resolvedInstance = new Map<
+        Parameters<typeof Application.make>[0],
+        unknown
+    >();
 
-  protected constructor() {}
+    protected constructor() {}
 
-  protected static getFacadeAccessor(): Parameters<typeof Application.make>[0] {
-    throw new Error("Facade does not implement getFacadeAccessor().");
-  }
-
-  static clearResolvedInstance(name: Parameters<typeof Application.make>[0]): void {
-    this.resolvedInstance.delete(name);
-  }
-
-  static clearResolvedInstances(): void {
-    this.resolvedInstance.clear();
-  }
+    protected static getFacadeAccessor(): Parameters<
+        typeof Application.make
+    >[0] {
+        throw new Error("Facade does not implement getFacadeAccessor().");
+    }
 
-  protected static resolveFacadeInstance<T>(): T {
-    const accessor = this.getFacadeAccessor();
+    static clearResolvedInstance(
+        name: Parameters<typeof Application.make>[0],
+    ): void {
+        this.resolvedInstance.delete(name);
+    }
 
-    if (this.resolvedInstance.has(accessor)) {
-      return this.resolvedInstance.get(accessor) as T;
+    static clearResolvedInstances(): void {
+        this.resolvedInstance.clear();
     }
 
-    const instance = Application.make<T>(accessor);
-    this.resolvedInstance.set(accessor, instance);
+    protected static resolveFacadeInstance<T>(): T {
+        const accessor = this.getFacadeAccessor();
+
+        if (this.resolvedInstance.has(accessor)) {
+            return this.resolvedInstance.get(accessor) as T;
+        }
 
-    return instance;
-  }
+        const instance = Application.make<T>(accessor);
+        this.resolvedInstance.set(accessor, instance);
 
-  protected static callFacadeMethod<T = unknown>(method: string, ...args: unknown[]): T {
-    const instance = this.resolveFacadeInstance<Record<string, (...a: unknown[]) => unknown>>();
-    const callable = instance[method];
-    if (typeof callable !== "function") {
-      throw new Error(`Method [${method}] does not exist on resolved facade instance.`);
+        return instance;
     }
 
-    return callable.apply(instance, args) as T;
-  }
+    protected static callFacadeMethod<T = unknown>(
+        method: string,
+        ...args: unknown[]
+    ): T {
+        const instance =
+            this.resolveFacadeInstance<
+                Record<string, (...a: unknown[]) => unknown>
+            >();
+        const callable = instance[method];
+        if (typeof callable !== "function") {
+            throw new Error(
+                `Method [${method}] does not exist on resolved facade instance.`,
+            );
+        }
+
+        return callable.apply(instance, args) as T;
+    }
 }

package/src/support/facades/storage.ts

@@ -1,46 +1,46 @@
 import type StorageManager from "../../storage/manager";
-import type { StorageAdapter } from "../../storage/storage";
+import type { Adapter } from "../../storage/adapters/contract";
 import Facade from "./facade";
 
 export default class Storage extends Facade {
-  private constructor() {
-    super();
-  }
-
-  protected static getFacadeAccessor(): string {
-    return "storage";
-  }
-
-  static drv(name?: string): StorageAdapter {
-    return this.resolveFacadeInstance<StorageManager>().drv(name);
-  }
-
-  static use(name: string): Storage {
-    this.resolveFacadeInstance<StorageManager>().use(name);
-    return this;
-  }
-
-  static get<T = unknown>(key: string): Promise<T | null> {
-    return this.resolveFacadeInstance<StorageManager>().get<T>(key);
-  }
-
-  static set<T = unknown>(key: string, value: T): Promise<void> {
-    return this.resolveFacadeInstance<StorageManager>().set<T>(key, value);
-  }
-
-  static has(key: string): Promise<boolean> {
-    return this.resolveFacadeInstance<StorageManager>().has(key);
-  }
-
-  static delete(key: string): Promise<void> {
-    return this.resolveFacadeInstance<StorageManager>().delete(key);
-  }
-
-  static clear(): Promise<void> {
-    return this.resolveFacadeInstance<StorageManager>().clear();
-  }
-
-  static keys(): Promise<string[]> {
-    return this.resolveFacadeInstance<StorageManager>().keys();
-  }
+    private constructor() {
+        super();
+    }
+
+    protected static getFacadeAccessor(): string {
+        return "storage";
+    }
+
+    static drv(name?: string): Adapter {
+        return this.resolveFacadeInstance<StorageManager>().drv(name);
+    }
+
+    static use(name: string): Storage {
+        this.resolveFacadeInstance<StorageManager>().use(name);
+        return this;
+    }
+
+    static get<T = unknown>(key: string): Promise<T | null> {
+        return this.resolveFacadeInstance<StorageManager>().get<T>(key);
+    }
+
+    static set<T = unknown>(key: string, value: T): Promise<void> {
+        return this.resolveFacadeInstance<StorageManager>().set<T>(key, value);
+    }
+
+    static has(key: string): Promise<boolean> {
+        return this.resolveFacadeInstance<StorageManager>().has(key);
+    }
+
+    static delete(key: string): Promise<void> {
+        return this.resolveFacadeInstance<StorageManager>().delete(key);
+    }
+
+    static clear(): Promise<void> {
+        return this.resolveFacadeInstance<StorageManager>().clear();
+    }
+
+    static keys(): Promise<string[]> {
+        return this.resolveFacadeInstance<StorageManager>().keys();
+    }
 }

package/src/support/service-provider.ts

@@ -1,25 +1,25 @@
-import type { Container } from "inversify";
+import type { ContainerContract } from "../container/contract";
 
 export type Cleanup = () => void;
 
 export type ServiceProviderContext = {
-  container: Container;
+    container: ContainerContract;
 };
 
 export default class ServiceProvider {
-  constructor() {}
+    constructor() {}
 
-  register(_context: ServiceProviderContext): void | Cleanup {}
+    register(_context: ServiceProviderContext): void | Cleanup {}
 
-  boot(_context: ServiceProviderContext): void | Cleanup {}
+    boot(_context: ServiceProviderContext): void | Cleanup {}
 }
 
 export class DeferrableServiceProvider extends ServiceProvider {
-  constructor() {
-    super();
-  }
+    constructor() {
+        super();
+    }
 
-  provides(): Array<string> {
-    return [];
-  }
+    provides(): Array<string> {
+        return [];
+    }
 }