@forklaunch/core 0.2.37 → 0.3.1

package/lib/services/index.d.mts

@@ -0,0 +1,69 @@
+import { AnySchemaValidator, IdiomaticSchema, Schema, ParseResult } from '@forklaunch/validator';
+import { EntityManager as EntityManager$1 } from '@mikro-orm/core';
+
+declare enum Lifetime {
+    Singleton = 0,
+    Transient = 1,
+    Scoped = 2
+}
+type Singleton<Value> = {
+    lifetime: Lifetime.Singleton;
+    value: Value;
+};
+type Constructed<Args, Return> = {
+    lifetime: Lifetime.Transient | Lifetime.Scoped;
+    factory: (args: Args, resolve: <T extends keyof Args>(token: T, context?: Record<string, unknown>) => Args[T], context: Record<string, unknown>) => Return;
+};
+type Constructor = new (...args: never[]) => unknown;
+type SchemaConstructor<SV extends AnySchemaValidator> = new (...args: unknown[]) => IdiomaticSchema<SV>;
+type Function = (...args: never[]) => unknown;
+type SchemaFunction<SV extends AnySchemaValidator> = (args: unknown) => IdiomaticSchema<SV>;
+type ConfigValidator<SV extends AnySchemaValidator> = Record<string, Function | SchemaFunction<SV> | Constructor | SchemaConstructor<SV> | IdiomaticSchema<SV>>;
+type ResolvedConfigValidator<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>> = {
+    [M in keyof CV]: CV[M] extends SchemaConstructor<SV> ? Schema<InstanceType<CV[M]>, SV> : CV[M] extends SchemaFunction<SV> ? Schema<ReturnType<CV[M]>, SV> : CV[M] extends Function ? ReturnType<CV[M]> : CV[M] extends Constructor ? InstanceType<CV[M]> : Schema<CV[M], SV>;
+};
+type ValidResolvedConfigValidator<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>> = ResolvedConfigValidator<SV, CV> & {
+    validResolvedConfigValidator: void;
+};
+type ScopedDependencyFactory<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>, M extends keyof CV> = (scope?: ConfigInjector<SV, CV>) => ResolvedConfigValidator<SV, CV>[M];
+
+declare class ConfigInjector<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>> {
+    private schemaValidator;
+    private configShapes;
+    private dependenciesDefinition;
+    instances: {
+        [K in keyof CV]?: ResolvedConfigValidator<SV, CV>[K];
+    };
+    private loadSingletons;
+    private resolveInstance;
+    constructor(schemaValidator: SV, configShapes: CV, dependenciesDefinition: {
+        [K in keyof CV]: Singleton<ResolvedConfigValidator<SV, CV>[K]> | Constructed<Omit<ResolvedConfigValidator<SV, CV>, K>, ResolvedConfigValidator<SV, CV>[K]>;
+    });
+    validateConfigSingletons(): ParseResult<ValidResolvedConfigValidator<SV, CV>>;
+    resolve<T extends keyof CV>(token: T, context?: Record<string, unknown>, resolutionPath?: (keyof CV)[]): ResolvedConfigValidator<SV, CV>[T];
+    scopedResolver<T extends keyof CV>(token: T, context?: Record<string, unknown>, resolutionPath?: (keyof CV)[]): (scope?: ConfigInjector<SV, CV>) => ResolvedConfigValidator<SV, CV>[T];
+    createScope(): ConfigInjector<SV, CV>;
+    dispose(): void;
+}
+
+declare function getEnvVar(name: string): string;
+
+/**
+ * Interface representing a base service.
+ *
+ * @interface BaseService
+ */
+interface BaseService {
+    /**
+     * The EntityManager instance for managing entities.
+     *
+     * @type {EntityManager}
+     */
+    em: EntityManager$1;
+}
+
+type EntityManager = {
+    fork: <Options>(options?: Options) => EntityManager;
+};
+
+export { type BaseService, ConfigInjector, type ConfigValidator, type Constructed, type Constructor, type EntityManager, type Function, Lifetime, type ResolvedConfigValidator, type SchemaConstructor, type SchemaFunction, type ScopedDependencyFactory, type Singleton, type ValidResolvedConfigValidator, getEnvVar };

package/lib/services/index.d.ts

@@ -0,0 +1,69 @@
+import { AnySchemaValidator, IdiomaticSchema, Schema, ParseResult } from '@forklaunch/validator';
+import { EntityManager as EntityManager$1 } from '@mikro-orm/core';
+
+declare enum Lifetime {
+    Singleton = 0,
+    Transient = 1,
+    Scoped = 2
+}
+type Singleton<Value> = {
+    lifetime: Lifetime.Singleton;
+    value: Value;
+};
+type Constructed<Args, Return> = {
+    lifetime: Lifetime.Transient | Lifetime.Scoped;
+    factory: (args: Args, resolve: <T extends keyof Args>(token: T, context?: Record<string, unknown>) => Args[T], context: Record<string, unknown>) => Return;
+};
+type Constructor = new (...args: never[]) => unknown;
+type SchemaConstructor<SV extends AnySchemaValidator> = new (...args: unknown[]) => IdiomaticSchema<SV>;
+type Function = (...args: never[]) => unknown;
+type SchemaFunction<SV extends AnySchemaValidator> = (args: unknown) => IdiomaticSchema<SV>;
+type ConfigValidator<SV extends AnySchemaValidator> = Record<string, Function | SchemaFunction<SV> | Constructor | SchemaConstructor<SV> | IdiomaticSchema<SV>>;
+type ResolvedConfigValidator<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>> = {
+    [M in keyof CV]: CV[M] extends SchemaConstructor<SV> ? Schema<InstanceType<CV[M]>, SV> : CV[M] extends SchemaFunction<SV> ? Schema<ReturnType<CV[M]>, SV> : CV[M] extends Function ? ReturnType<CV[M]> : CV[M] extends Constructor ? InstanceType<CV[M]> : Schema<CV[M], SV>;
+};
+type ValidResolvedConfigValidator<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>> = ResolvedConfigValidator<SV, CV> & {
+    validResolvedConfigValidator: void;
+};
+type ScopedDependencyFactory<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>, M extends keyof CV> = (scope?: ConfigInjector<SV, CV>) => ResolvedConfigValidator<SV, CV>[M];
+
+declare class ConfigInjector<SV extends AnySchemaValidator, CV extends ConfigValidator<SV>> {
+    private schemaValidator;
+    private configShapes;
+    private dependenciesDefinition;
+    instances: {
+        [K in keyof CV]?: ResolvedConfigValidator<SV, CV>[K];
+    };
+    private loadSingletons;
+    private resolveInstance;
+    constructor(schemaValidator: SV, configShapes: CV, dependenciesDefinition: {
+        [K in keyof CV]: Singleton<ResolvedConfigValidator<SV, CV>[K]> | Constructed<Omit<ResolvedConfigValidator<SV, CV>, K>, ResolvedConfigValidator<SV, CV>[K]>;
+    });
+    validateConfigSingletons(): ParseResult<ValidResolvedConfigValidator<SV, CV>>;
+    resolve<T extends keyof CV>(token: T, context?: Record<string, unknown>, resolutionPath?: (keyof CV)[]): ResolvedConfigValidator<SV, CV>[T];
+    scopedResolver<T extends keyof CV>(token: T, context?: Record<string, unknown>, resolutionPath?: (keyof CV)[]): (scope?: ConfigInjector<SV, CV>) => ResolvedConfigValidator<SV, CV>[T];
+    createScope(): ConfigInjector<SV, CV>;
+    dispose(): void;
+}
+
+declare function getEnvVar(name: string): string;
+
+/**
+ * Interface representing a base service.
+ *
+ * @interface BaseService
+ */
+interface BaseService {
+    /**
+     * The EntityManager instance for managing entities.
+     *
+     * @type {EntityManager}
+     */
+    em: EntityManager$1;
+}
+
+type EntityManager = {
+    fork: <Options>(options?: Options) => EntityManager;
+};
+
+export { type BaseService, ConfigInjector, type ConfigValidator, type Constructed, type Constructor, type EntityManager, type Function, Lifetime, type ResolvedConfigValidator, type SchemaConstructor, type SchemaFunction, type ScopedDependencyFactory, type Singleton, type ValidResolvedConfigValidator, getEnvVar };

package/lib/services/index.js

@@ -0,0 +1,244 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/index.ts
+var services_exports = {};
+__export(services_exports, {
+  ConfigInjector: () => ConfigInjector,
+  Lifetime: () => Lifetime,
+  getEnvVar: () => getEnvVar
+});
+module.exports = __toCommonJS(services_exports);
+
+// src/services/configInjector.ts
+var import_common = require("@forklaunch/common");
+
+// src/services/guards/isConstructed.ts
+function isConstructed(value) {
+  return typeof value === "object" && value != null && "constructor" in value && value.constructor != null;
+}
+
+// src/services/guards/isConstructor.ts
+function isConstructor(value) {
+  return typeof value === "function" && value.constructor != null && value.prototype != null;
+}
+
+// src/services/types/configInjector.types.ts
+var Lifetime = /* @__PURE__ */ ((Lifetime2) => {
+  Lifetime2[Lifetime2["Singleton"] = 0] = "Singleton";
+  Lifetime2[Lifetime2["Transient"] = 1] = "Transient";
+  Lifetime2[Lifetime2["Scoped"] = 2] = "Scoped";
+  return Lifetime2;
+})(Lifetime || {});
+
+// src/services/configInjector.ts
+var ConfigInjector = class _ConfigInjector {
+  constructor(schemaValidator, configShapes, dependenciesDefinition) {
+    this.schemaValidator = schemaValidator;
+    this.configShapes = configShapes;
+    this.dependenciesDefinition = dependenciesDefinition;
+    this.loadSingletons();
+  }
+  instances = {};
+  loadSingletons() {
+    for (const token in this.dependenciesDefinition) {
+      const definition = this.dependenciesDefinition[token];
+      if (definition.lifetime === 0 /* Singleton */) {
+        this.instances[token] = definition.value;
+      }
+    }
+  }
+  resolveInstance(token, definition, context, resolutionPath = []) {
+    const injectorArgument = (0, import_common.extractArgumentNames)(definition.factory)[0];
+    if (injectorArgument === "_args") {
+      return definition.factory(
+        {},
+        this.resolve.bind(this),
+        context ?? {}
+      );
+    }
+    if (!injectorArgument.startsWith("{") || !injectorArgument.endsWith("}")) {
+      throw new Error(
+        `Invalid injector argument for ${String(
+          token
+        )}: ${injectorArgument}. Please use object destructuring syntax: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment.`
+      );
+    }
+    const resolvedArguments = Object.fromEntries(
+      injectorArgument.replace("{", "").replace("}", "").split(",").map((arg) => arg.split(":")[0].trim()).map((arg) => {
+        const newResolutionPath = [...resolutionPath, token];
+        if (resolutionPath.includes(arg)) {
+          throw new Error(
+            `Circular dependency detected: ${newResolutionPath.join(
+              " -> "
+            )} -> ${arg}`
+          );
+        }
+        const resolvedArg = this.resolve(arg, context, newResolutionPath);
+        return [arg, resolvedArg];
+      })
+    );
+    return definition.factory(
+      resolvedArguments,
+      this.resolve.bind(this),
+      context ?? {}
+    );
+  }
+  validateConfigSingletons() {
+    const validNonSchemaSingletons = Object.entries(this.configShapes).reduce(
+      (acc, [key, value]) => {
+        if (this.dependenciesDefinition[key].lifetime === 0 /* Singleton */ && !this.schemaValidator.isSchema(value) && isConstructor(value)) {
+          if (!(this.dependenciesDefinition[key].value instanceof value)) {
+            const expected = value.name;
+            const receivedValue = this.dependenciesDefinition[key].value;
+            const received = isConstructed(receivedValue) ? receivedValue.constructor.name : typeof receivedValue;
+            if (acc.ok) {
+              acc = {
+                ok: false,
+                errors: []
+              };
+            }
+            acc.errors?.push({
+              message: `Expected ${expected}, received ${received}`,
+              path: [key]
+            });
+          } else {
+            if (acc.ok) {
+              acc = {
+                ok: true,
+                value: {
+                  ...acc.value,
+                  [key]: this.dependenciesDefinition[key].value
+                }
+              };
+            }
+          }
+          return acc;
+        }
+        return acc;
+      },
+      {
+        ok: true,
+        value: {}
+      }
+    );
+    const singletons = Object.fromEntries(
+      Object.entries(this.configShapes).filter(
+        ([key, value]) => this.dependenciesDefinition[key].lifetime === 0 /* Singleton */ && this.schemaValidator.isSchema(value)
+      )
+    );
+    const schemaSingletonParseResult = this.schemaValidator.parse(
+      this.schemaValidator.schemify(singletons),
+      Object.fromEntries(
+        Object.keys(singletons).map((key) => {
+          const dependency = this.dependenciesDefinition[key];
+          return [
+            key,
+            dependency.lifetime === 0 /* Singleton */ ? dependency.value : void 0
+          ];
+        })
+      )
+    );
+    const configKeys = Object.keys(this.configShapes);
+    return validNonSchemaSingletons.ok && schemaSingletonParseResult.ok ? {
+      ok: true,
+      value: {
+        validResolvedConfigValidator: void 0,
+        ...validNonSchemaSingletons.value,
+        ...schemaSingletonParseResult.value
+      }
+    } : {
+      ok: false,
+      errors: [
+        ...!validNonSchemaSingletons.ok && validNonSchemaSingletons.errors ? validNonSchemaSingletons.errors : [],
+        ...!schemaSingletonParseResult.ok && schemaSingletonParseResult.errors ? schemaSingletonParseResult.errors : []
+      ].sort(
+        (a, b) => configKeys.indexOf(a.path[0]) - configKeys.indexOf(b.path[0])
+      )
+    };
+  }
+  resolve(token, context, resolutionPath = []) {
+    const instance = this.instances[token];
+    if (!instance) {
+      const definition = this.dependenciesDefinition[token];
+      if (!definition) {
+        throw new Error(`Unable to resolve dependency ${String(token)}`);
+      }
+      switch (definition.lifetime) {
+        case 0 /* Singleton */: {
+          return definition.value;
+        }
+        case 2 /* Scoped */: {
+          const scopedInstance = this.resolveInstance(
+            token,
+            definition,
+            context,
+            resolutionPath
+          );
+          this.instances[token] = scopedInstance;
+          return scopedInstance;
+        }
+        case 1 /* Transient */: {
+          return this.resolveInstance(
+            token,
+            definition,
+            context,
+            resolutionPath
+          );
+        }
+        default: {
+          (0, import_common.isNever)(definition);
+          throw new Error(
+            `Unable to resolve lifetime for dependency ${String(
+              token
+            )}, ${resolutionPath}`
+          );
+        }
+      }
+    } else {
+      return instance;
+    }
+  }
+  scopedResolver(token, context, resolutionPath = []) {
+    return (scope) => (scope ?? this.createScope()).resolve(token, context, resolutionPath);
+  }
+  createScope() {
+    return new _ConfigInjector(
+      this.schemaValidator,
+      this.configShapes,
+      this.dependenciesDefinition
+    );
+  }
+  dispose() {
+    this.instances = {};
+    this.loadSingletons();
+  }
+};
+
+// src/services/getEnvVar.ts
+function getEnvVar(name) {
+  const value = process.env[name];
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigInjector,
+  Lifetime,
+  getEnvVar
+});

package/lib/services/index.mjs

@@ -0,0 +1,215 @@
+// src/services/configInjector.ts
+import { extractArgumentNames, isNever } from "@forklaunch/common";
+
+// src/services/guards/isConstructed.ts
+function isConstructed(value) {
+  return typeof value === "object" && value != null && "constructor" in value && value.constructor != null;
+}
+
+// src/services/guards/isConstructor.ts
+function isConstructor(value) {
+  return typeof value === "function" && value.constructor != null && value.prototype != null;
+}
+
+// src/services/types/configInjector.types.ts
+var Lifetime = /* @__PURE__ */ ((Lifetime2) => {
+  Lifetime2[Lifetime2["Singleton"] = 0] = "Singleton";
+  Lifetime2[Lifetime2["Transient"] = 1] = "Transient";
+  Lifetime2[Lifetime2["Scoped"] = 2] = "Scoped";
+  return Lifetime2;
+})(Lifetime || {});
+
+// src/services/configInjector.ts
+var ConfigInjector = class _ConfigInjector {
+  constructor(schemaValidator, configShapes, dependenciesDefinition) {
+    this.schemaValidator = schemaValidator;
+    this.configShapes = configShapes;
+    this.dependenciesDefinition = dependenciesDefinition;
+    this.loadSingletons();
+  }
+  instances = {};
+  loadSingletons() {
+    for (const token in this.dependenciesDefinition) {
+      const definition = this.dependenciesDefinition[token];
+      if (definition.lifetime === 0 /* Singleton */) {
+        this.instances[token] = definition.value;
+      }
+    }
+  }
+  resolveInstance(token, definition, context, resolutionPath = []) {
+    const injectorArgument = extractArgumentNames(definition.factory)[0];
+    if (injectorArgument === "_args") {
+      return definition.factory(
+        {},
+        this.resolve.bind(this),
+        context ?? {}
+      );
+    }
+    if (!injectorArgument.startsWith("{") || !injectorArgument.endsWith("}")) {
+      throw new Error(
+        `Invalid injector argument for ${String(
+          token
+        )}: ${injectorArgument}. Please use object destructuring syntax: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment.`
+      );
+    }
+    const resolvedArguments = Object.fromEntries(
+      injectorArgument.replace("{", "").replace("}", "").split(",").map((arg) => arg.split(":")[0].trim()).map((arg) => {
+        const newResolutionPath = [...resolutionPath, token];
+        if (resolutionPath.includes(arg)) {
+          throw new Error(
+            `Circular dependency detected: ${newResolutionPath.join(
+              " -> "
+            )} -> ${arg}`
+          );
+        }
+        const resolvedArg = this.resolve(arg, context, newResolutionPath);
+        return [arg, resolvedArg];
+      })
+    );
+    return definition.factory(
+      resolvedArguments,
+      this.resolve.bind(this),
+      context ?? {}
+    );
+  }
+  validateConfigSingletons() {
+    const validNonSchemaSingletons = Object.entries(this.configShapes).reduce(
+      (acc, [key, value]) => {
+        if (this.dependenciesDefinition[key].lifetime === 0 /* Singleton */ && !this.schemaValidator.isSchema(value) && isConstructor(value)) {
+          if (!(this.dependenciesDefinition[key].value instanceof value)) {
+            const expected = value.name;
+            const receivedValue = this.dependenciesDefinition[key].value;
+            const received = isConstructed(receivedValue) ? receivedValue.constructor.name : typeof receivedValue;
+            if (acc.ok) {
+              acc = {
+                ok: false,
+                errors: []
+              };
+            }
+            acc.errors?.push({
+              message: `Expected ${expected}, received ${received}`,
+              path: [key]
+            });
+          } else {
+            if (acc.ok) {
+              acc = {
+                ok: true,
+                value: {
+                  ...acc.value,
+                  [key]: this.dependenciesDefinition[key].value
+                }
+              };
+            }
+          }
+          return acc;
+        }
+        return acc;
+      },
+      {
+        ok: true,
+        value: {}
+      }
+    );
+    const singletons = Object.fromEntries(
+      Object.entries(this.configShapes).filter(
+        ([key, value]) => this.dependenciesDefinition[key].lifetime === 0 /* Singleton */ && this.schemaValidator.isSchema(value)
+      )
+    );
+    const schemaSingletonParseResult = this.schemaValidator.parse(
+      this.schemaValidator.schemify(singletons),
+      Object.fromEntries(
+        Object.keys(singletons).map((key) => {
+          const dependency = this.dependenciesDefinition[key];
+          return [
+            key,
+            dependency.lifetime === 0 /* Singleton */ ? dependency.value : void 0
+          ];
+        })
+      )
+    );
+    const configKeys = Object.keys(this.configShapes);
+    return validNonSchemaSingletons.ok && schemaSingletonParseResult.ok ? {
+      ok: true,
+      value: {
+        validResolvedConfigValidator: void 0,
+        ...validNonSchemaSingletons.value,
+        ...schemaSingletonParseResult.value
+      }
+    } : {
+      ok: false,
+      errors: [
+        ...!validNonSchemaSingletons.ok && validNonSchemaSingletons.errors ? validNonSchemaSingletons.errors : [],
+        ...!schemaSingletonParseResult.ok && schemaSingletonParseResult.errors ? schemaSingletonParseResult.errors : []
+      ].sort(
+        (a, b) => configKeys.indexOf(a.path[0]) - configKeys.indexOf(b.path[0])
+      )
+    };
+  }
+  resolve(token, context, resolutionPath = []) {
+    const instance = this.instances[token];
+    if (!instance) {
+      const definition = this.dependenciesDefinition[token];
+      if (!definition) {
+        throw new Error(`Unable to resolve dependency ${String(token)}`);
+      }
+      switch (definition.lifetime) {
+        case 0 /* Singleton */: {
+          return definition.value;
+        }
+        case 2 /* Scoped */: {
+          const scopedInstance = this.resolveInstance(
+            token,
+            definition,
+            context,
+            resolutionPath
+          );
+          this.instances[token] = scopedInstance;
+          return scopedInstance;
+        }
+        case 1 /* Transient */: {
+          return this.resolveInstance(
+            token,
+            definition,
+            context,
+            resolutionPath
+          );
+        }
+        default: {
+          isNever(definition);
+          throw new Error(
+            `Unable to resolve lifetime for dependency ${String(
+              token
+            )}, ${resolutionPath}`
+          );
+        }
+      }
+    } else {
+      return instance;
+    }
+  }
+  scopedResolver(token, context, resolutionPath = []) {
+    return (scope) => (scope ?? this.createScope()).resolve(token, context, resolutionPath);
+  }
+  createScope() {
+    return new _ConfigInjector(
+      this.schemaValidator,
+      this.configShapes,
+      this.dependenciesDefinition
+    );
+  }
+  dispose() {
+    this.instances = {};
+    this.loadSingletons();
+  }
+};
+
+// src/services/getEnvVar.ts
+function getEnvVar(name) {
+  const value = process.env[name];
+  return value;
+}
+export {
+  ConfigInjector,
+  Lifetime,
+  getEnvVar
+};