@raubjo/architect-core 0.1.0 → 0.1.2

package/src/config/clone.ts

@@ -1,9 +1,9 @@
-import type { ConfigItems } from "./repository";
+import type { ConfigItems } from "@/config/repository";
 
 export function cloneConfigItems(items: ConfigItems): ConfigItems {
-  if (typeof structuredClone === "function") {
-    return structuredClone(items) as ConfigItems;
-  }
+    if (typeof structuredClone === "function") {
+        return structuredClone(items) as ConfigItems;
+    }
 
-  return JSON.parse(JSON.stringify(items)) as ConfigItems;
+    return JSON.parse(JSON.stringify(items)) as ConfigItems;
 }

package/src/config/env.global.d.ts

@@ -1,5 +1,6 @@
 declare global {
-  function env<T = unknown>(key: string, defaultValue?: T | null): T | unknown | null;
+    function env(key: string): import("./env").EnvValue | undefined;
+    function env<T>(key: string, defaultValue: T): import("./env").EnvValue | T;
 }
 
 export {};

package/src/config/env.ts

@@ -1,79 +1,77 @@
-type EnvMap = Record<string, unknown>;
+export type EnvValue = string | number | boolean | null;
+type EnvMap = Record<string, EnvValue | undefined>;
 
-function normalizeEnvValue(value: unknown): unknown {
-  if (typeof value !== "string") {
-    return value;
-  }
+function normalizeEnvValue(value: EnvValue | undefined): EnvValue | undefined {
+    if (typeof value !== "string") {
+        return value;
+    }
 
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "true" || normalized === "(true)") {
-    return true;
-  }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "(true)") {
+        return true;
+    }
 
-  if (normalized === "false" || normalized === "(false)") {
-    return false;
-  }
+    if (normalized === "false" || normalized === "(false)") {
+        return false;
+    }
 
-  if (normalized === "null" || normalized === "(null)") {
-    return null;
-  }
+    if (normalized === "null" || normalized === "(null)") {
+        return null;
+    }
 
-  if (normalized === "empty" || normalized === "(empty)") {
-    return "";
-  }
+    if (normalized === "empty" || normalized === "(empty)") {
+        return "";
+    }
 
-  return value;
+    return value;
 }
 
 function resolveProcessEnv(): EnvMap {
-  const processValue = (
-    globalThis as { process?: { env?: EnvMap } }
-  ).process;
+    const processValue = (globalThis as { process?: { env?: EnvMap } }).process;
 
-  if (!processValue?.env) {
-    return {};
-  }
+    if (!processValue?.env) {
+        return {};
+    }
 
-  return processValue.env;
+    return processValue.env;
 }
 
 function resolveImportMetaEnv(): EnvMap {
-  const testEnv = (
-    globalThis as {
-      __iocImportMetaEnvForTests?: EnvMap;
+    const testEnv = (
+        globalThis as {
+            __iocImportMetaEnvForTests?: EnvMap;
+        }
+    ).__iocImportMetaEnvForTests;
+    if (testEnv) {
+        return testEnv;
     }
-  ).__iocImportMetaEnvForTests;
-  if (testEnv) {
-    return testEnv;
-  }
 
-  const meta = import.meta as ImportMeta & { env?: EnvMap };
-  return meta.env ?? {};
+    const meta = import.meta as ImportMeta & { env?: EnvMap };
+    return meta.env ?? {};
 }
 
-export function env<T = unknown>(key: string, defaultValue: T | null = null): T | unknown | null {
-  const importMetaEnv = resolveImportMetaEnv();
-  if (key in importMetaEnv) {
-    return normalizeEnvValue(importMetaEnv[key]);
-  }
+export function env(key: string): EnvValue | undefined;
+export function env<T>(key: string, defaultValue: T): EnvValue | T;
+export function env<T>(
+    key: string,
+    defaultValue?: T,
+): EnvValue | T | undefined {
+    const importMetaEnv = resolveImportMetaEnv();
+    if (key in importMetaEnv) {
+        return normalizeEnvValue(importMetaEnv[key]);
+    }
 
-  const processEnv = resolveProcessEnv();
-  if (key in processEnv) {
-    return normalizeEnvValue(processEnv[key]);
-  }
+    const processEnv = resolveProcessEnv();
+    if (key in processEnv) {
+        return normalizeEnvValue(processEnv[key]);
+    }
 
-  return defaultValue;
+    return defaultValue;
 }
 
 export function registerGlobalEnv(): void {
-  const globalScope = globalThis as { env?: typeof env };
-  if (typeof globalScope.env !== "function") {
-    globalScope.env = env;
-  }
+    const globalScope = globalThis as { env?: typeof env };
+    if (typeof globalScope.env !== "function") {
+        globalScope.env = env;
+    }
 }
-
-export const __envTesting = {
-  normalizeEnvValue,
-  resolveImportMetaEnv,
-  resolveProcessEnv,
-};

package/src/config/env_test.helpers.ts

@@ -0,0 +1,58 @@
+import type { EnvValue } from "./env";
+
+type EnvMap = Record<string, EnvValue | undefined>;
+
+function normalizeEnvValue(value: EnvValue | undefined): EnvValue | undefined {
+    if (typeof value !== "string") {
+        return value;
+    }
+
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "(true)") {
+        return true;
+    }
+
+    if (normalized === "false" || normalized === "(false)") {
+        return false;
+    }
+
+    if (normalized === "null" || normalized === "(null)") {
+        return null;
+    }
+
+    if (normalized === "empty" || normalized === "(empty)") {
+        return "";
+    }
+
+    return value;
+}
+
+function resolveProcessEnv(): EnvMap {
+    const processValue = (globalThis as { process?: { env?: EnvMap } }).process;
+
+    if (!processValue?.env) {
+        return {};
+    }
+
+    return processValue.env;
+}
+
+function resolveImportMetaEnv(): EnvMap {
+    const testEnv = (
+        globalThis as {
+            __iocImportMetaEnvForTests?: EnvMap;
+        }
+    ).__iocImportMetaEnvForTests;
+    if (testEnv) {
+        return testEnv;
+    }
+
+    const meta = import.meta as ImportMeta & { env?: EnvMap };
+    return meta.env ?? {};
+}
+
+export const envTestingHelpers = {
+    normalizeEnvValue,
+    resolveImportMetaEnv,
+    resolveProcessEnv,
+};

package/src/config/repository.ts

@@ -2,203 +2,241 @@ export type ConfigItems = Record<string, unknown>;
 export type ConfigDefaults = Record<string | number, unknown>;
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 function resolveDefault<T>(defaultValue: T | (() => T)): T {
-  return typeof defaultValue === "function" ? (defaultValue as () => T)() : defaultValue;
+    return typeof defaultValue === "function" ?
+            (defaultValue as () => T)()
+        :   defaultValue;
 }
 
-function dataGet(source: unknown, path: string, defaultValue: unknown = null): unknown {
-  if (!path) {
-    return source;
-  }
+function dataGet(
+    source: unknown,
+    path: string,
+    defaultValue: unknown = null,
+): unknown {
+    if (!path) {
+        return source;
+    }
 
-  const segments = path.split(".");
-  let cursor: unknown = source;
+    const segments = path.split(".");
+    let cursor: unknown = source;
 
-  for (const segment of segments) {
-    if (isPlainObject(cursor) && segment in cursor) {
-      cursor = cursor[segment];
-      continue;
-    }
+    for (const segment of segments) {
+        if (isPlainObject(cursor) && segment in cursor) {
+            cursor = cursor[segment];
+            continue;
+        }
 
-    return resolveDefault(defaultValue);
-  }
+        return resolveDefault(defaultValue);
+    }
 
-  return cursor;
+    return cursor;
 }
 
-function dataSet(target: Record<string, unknown>, path: string, value: unknown): void {
-  const segments = path.split(".");
-  let cursor: Record<string, unknown> = target;
+function dataSet(
+    target: Record<string, unknown>,
+    path: string,
+    value: unknown,
+): void {
+    const segments = path.split(".");
+    let cursor: Record<string, unknown> = target;
 
-  for (let i = 0; i < segments.length; i += 1) {
-    const segment = segments[i];
-    const isLast = i === segments.length - 1;
+    for (let i = 0; i < segments.length; i += 1) {
+        const segment = segments[i];
+        const isLast = i === segments.length - 1;
 
-    if (isLast) {
-      cursor[segment] = value;
-      return;
-    }
+        if (isLast) {
+            cursor[segment] = value;
+            return;
+        }
 
-    if (!isPlainObject(cursor[segment])) {
-      cursor[segment] = {};
-    }
+        if (!isPlainObject(cursor[segment])) {
+            cursor[segment] = {};
+        }
 
-    cursor = cursor[segment] as Record<string, unknown>;
-  }
+        cursor = cursor[segment] as Record<string, unknown>;
+    }
 }
 
 function dataForget(target: Record<string, unknown>, path: string): void {
-  const segments = path.split(".");
-  let cursor: Record<string, unknown> = target;
+    const segments = path.split(".");
+    let cursor: Record<string, unknown> = target;
 
-  for (let i = 0; i < segments.length; i += 1) {
-    const segment = segments[i];
-    const isLast = i === segments.length - 1;
+    for (let i = 0; i < segments.length; i += 1) {
+        const segment = segments[i];
+        const isLast = i === segments.length - 1;
 
-    if (isLast) {
-      delete cursor[segment];
-      return;
-    }
+        if (isLast) {
+            delete cursor[segment];
+            return;
+        }
 
-    if (!isPlainObject(cursor[segment])) {
-      return;
-    }
+        if (!isPlainObject(cursor[segment])) {
+            return;
+        }
 
-    cursor = cursor[segment] as Record<string, unknown>;
-  }
+        cursor = cursor[segment] as Record<string, unknown>;
+    }
 }
 
 export default class ConfigRepository {
-  protected items: ConfigItems;
-
-  constructor(items: ConfigItems = {}) {
-    this.items = items;
-  }
+    protected items: ConfigItems;
 
-  has(key: string | string[]): boolean {
-    const keys = Array.isArray(key) ? key : [key];
-    for (const configKey of keys) {
-      if (this.get(configKey) == null) {
-        return false;
-      }
+    constructor(items: ConfigItems = {}) {
+        this.items = items;
     }
 
-    return true;
-  }
+    has(key: string | string[]): boolean {
+        const keys = Array.isArray(key) ? key : [key];
+        for (const configKey of keys) {
+            if (this.get(configKey) == null) {
+                return false;
+            }
+        }
 
-  get<T = unknown>(
-    key: string | string[],
-    defaultValue: T | (() => T) | null = null,
-  ): T | Record<string, unknown> | null {
-    if (Array.isArray(key)) {
-      return this.getMany(key);
+        return true;
     }
 
-    return dataGet(this.items, key, defaultValue) as T | null;
-  }
-
-  getMany(keys: string[] | ConfigDefaults): Record<string, unknown> {
-    const results: Record<string, unknown> = {};
-
-    if (Array.isArray(keys)) {
-      for (const key of keys) {
-        results[key] = this.get(key);
-      }
-
-      return results;
+    get<T = unknown>(
+        key: string,
+        defaultValue?: T | (() => T) | null,
+    ): T | null;
+    get(key: string[]): Record<string, unknown>;
+    get<T = unknown>(
+        key: string | string[],
+        defaultValue: T | (() => T) | null = null,
+    ): T | Record<string, unknown> | null {
+        if (Array.isArray(key)) {
+            return this.getMany(key);
+        }
+
+        return dataGet(this.items, key, defaultValue) as T | null;
     }
 
-    for (const [key, defaultValue] of Object.entries(keys)) {
-      results[key] = this.get(key, defaultValue);
-    }
+    getMany(keys: string[] | ConfigDefaults): Record<string, unknown> {
+        const results: Record<string, unknown> = {};
 
-    return results;
-  }
+        if (Array.isArray(keys)) {
+            for (const key of keys) {
+                results[key] = this.get(key);
+            }
 
-  string(key: string, defaultValue: string | (() => string) | null = null): string {
-    const value = this.get<string>(key, defaultValue);
-    if (typeof value !== "string") {
-      throw new TypeError(`Configuration value [${key}] is not a string.`);
-    }
+            return results;
+        }
 
-    return value;
-  }
+        for (const [key, defaultValue] of Object.entries(keys)) {
+            results[key] = this.get(key, defaultValue);
+        }
 
-  integer(key: string, defaultValue: number | (() => number) | null = null): number {
-    const value = this.get<number>(key, defaultValue);
-    if (!Number.isInteger(value)) {
-      throw new TypeError(`Configuration value [${key}] is not an integer.`);
+        return results;
     }
 
-    return value;
-  }
+    string(
+        key: string,
+        defaultValue: string | (() => string) | null = null,
+    ): string {
+        const value = this.get<string>(key, defaultValue);
+        if (typeof value !== "string") {
+            throw new TypeError(
+                `Configuration value [${key}] is not a string.`,
+            );
+        }
+
+        return value;
+    }
 
-  float(key: string, defaultValue: number | (() => number) | null = null): number {
-    const value = this.get<number>(key, defaultValue);
-    if (typeof value !== "number" || Number.isNaN(value)) {
-      throw new TypeError(`Configuration value [${key}] is not a float.`);
+    integer(
+        key: string,
+        defaultValue: number | (() => number) | null = null,
+    ): number {
+        const value = this.get<number>(key, defaultValue);
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+            throw new TypeError(
+                `Configuration value [${key}] is not an integer.`,
+            );
+        }
+
+        return value;
     }
 
-    return value;
-  }
+    float(
+        key: string,
+        defaultValue: number | (() => number) | null = null,
+    ): number {
+        const value = this.get<number>(key, defaultValue);
+        if (typeof value !== "number" || Number.isNaN(value)) {
+            throw new TypeError(`Configuration value [${key}] is not a float.`);
+        }
 
-  boolean(key: string, defaultValue: boolean | (() => boolean) | null = null): boolean {
-    const value = this.get<boolean>(key, defaultValue);
-    if (typeof value !== "boolean") {
-      throw new TypeError(`Configuration value [${key}] is not a boolean.`);
+        return value;
     }
 
-    return value;
-  }
-
-  array<T = unknown>(key: string, defaultValue: T[] | (() => T[]) | null = null): T[] {
-    const value = this.get<T[]>(key, defaultValue);
-    if (!Array.isArray(value)) {
-      throw new TypeError(`Configuration value [${key}] is not an array.`);
+    boolean(
+        key: string,
+        defaultValue: boolean | (() => boolean) | null = null,
+    ): boolean {
+        const value = this.get<boolean>(key, defaultValue);
+        if (typeof value !== "boolean") {
+            throw new TypeError(
+                `Configuration value [${key}] is not a boolean.`,
+            );
+        }
+
+        return value;
     }
 
-    return value;
-  }
+    array<T = unknown>(
+        key: string,
+        defaultValue: T[] | (() => T[]) | null = null,
+    ): T[] {
+        const value = this.get<T[]>(key, defaultValue);
+        if (!Array.isArray(value)) {
+            throw new TypeError(
+                `Configuration value [${key}] is not an array.`,
+            );
+        }
+
+        return value;
+    }
 
-  set(key: string | ConfigItems, value: unknown = null): void {
-    const payload = isPlainObject(key) ? key : { [key]: value };
+    set(key: string | ConfigItems, value: unknown = null): void {
+        const payload = isPlainObject(key) ? key : { [key]: value };
 
-    for (const [configKey, configValue] of Object.entries(payload)) {
-      dataSet(this.items, configKey, configValue);
+        for (const [configKey, configValue] of Object.entries(payload)) {
+            dataSet(this.items, configKey, configValue);
+        }
     }
-  }
 
-  prepend(key: string, value: unknown): void {
-    const values = this.array<unknown>(key, []);
-    this.set(key, [value, ...values]);
-  }
+    prepend(key: string, value: unknown): void {
+        const values = this.array<unknown>(key, []);
+        this.set(key, [value, ...values]);
+    }
 
-  push(key: string, value: unknown): void {
-    const values = this.array<unknown>(key, []);
-    values.push(value);
-    this.set(key, values);
-  }
+    push(key: string, value: unknown): void {
+        const values = this.array<unknown>(key, []);
+        values.push(value);
+        this.set(key, values);
+    }
 
-  all(): ConfigItems {
-    return this.items;
-  }
+    all(): ConfigItems {
+        return this.items;
+    }
 
-  offsetExists(key: string): boolean {
-    return this.has(key);
-  }
+    offsetExists(key: string): boolean {
+        return this.has(key);
+    }
 
-  offsetGet<T = unknown>(key: string): T | null {
-    return this.get<T>(key) as T | null;
-  }
+    offsetGet<T = unknown>(key: string): T | null {
+        return this.get<T>(key) as T | null;
+    }
 
-  offsetSet(key: string, value: unknown): void {
-    this.set(key, value);
-  }
+    offsetSet(key: string, value: unknown): void {
+        this.set(key, value);
+    }
 
-  offsetUnset(key: string): void {
-    dataForget(this.items, key);
-  }
+    offsetUnset(key: string): void {
+        dataForget(this.items, key);
+    }
 }