@chidchanun/bcp 0.2.19 → 0.3.1

package/packages/client/src/application.ts

@@ -0,0 +1,12 @@
+export {
+    ApplicationLifecycleError,
+    createApp,
+    defineApp,
+
+    type Application,
+    type ApplicationConfigParser,
+    type ApplicationConfigSchema,
+    type ApplicationContext,
+    type ApplicationDefinition,
+    type ApplicationState,
+} from "../../server/src/application.js";

package/packages/client/src/container.mjs

@@ -0,0 +1,573 @@
+// packages/server/src/container.ts
+var ServiceNotFoundError = class extends Error {
+  token;
+  constructor(token) {
+    super(
+      `BCP Container: service "${token.description}" is not registered.`
+    );
+    this.name = "ServiceNotFoundError";
+    this.token = token;
+  }
+};
+var ServiceResolutionError = class extends Error {
+  token;
+  cause;
+  constructor(token, message, cause) {
+    super(
+      `BCP Container: could not resolve "${token.description}". ${message}`
+    );
+    this.name = "ServiceResolutionError";
+    this.token = token;
+    this.cause = cause;
+  }
+};
+var ServiceDisposalError = class extends AggregateError {
+  constructor(errors) {
+    super(
+      errors,
+      "BCP Container: one or more services failed to dispose."
+    );
+    this.name = "ServiceDisposalError";
+  }
+};
+function createServiceToken(description) {
+  const normalized = normalizeName(
+    description,
+    "service token description"
+  );
+  return Object.freeze({
+    id: Symbol(normalized),
+    description: normalized
+  });
+}
+function provideValue(token, value, options = {}) {
+  assertToken(token);
+  return {
+    token,
+    lifetime: "singleton",
+    factory() {
+      return value;
+    },
+    ...options.dispose ? {
+      dispose: options.dispose
+    } : {}
+  };
+}
+function provideFactory(token, dependencies, factory, options = {}) {
+  assertToken(token);
+  assertDependencies(dependencies);
+  const lifetime = normalizeLifetime(
+    options.lifetime
+  );
+  return {
+    token,
+    lifetime,
+    dependencies: [
+      ...dependencies
+    ],
+    factory(context, values) {
+      return factory(
+        context,
+        values
+      );
+    },
+    ...options.dispose ? {
+      dispose: options.dispose
+    } : {}
+  };
+}
+function provideClass(token, dependencies, Constructor, options = {}) {
+  if (typeof Constructor !== "function") {
+    throw new TypeError(
+      "BCP Container: service constructor must be a function."
+    );
+  }
+  return provideFactory(
+    token,
+    dependencies,
+    (_context, values) => new Constructor(
+      ...values
+    ),
+    options
+  );
+}
+function createServiceContainer(options = {}) {
+  const root = new ScopeImpl(
+    normalizeOptionalName(
+      options.name
+    ) ?? "root",
+    void 0
+  );
+  root.root = root;
+  const container = {
+    get name() {
+      return root.name;
+    },
+    get state() {
+      return root.state;
+    },
+    get parent() {
+      return void 0;
+    },
+    has(token) {
+      return root.has(token);
+    },
+    resolve(token) {
+      return root.resolve(token);
+    },
+    optional(token) {
+      return root.optional(token);
+    },
+    createScope(scopeOptions = {}) {
+      return root.createScope(
+        scopeOptions
+      );
+    },
+    graph() {
+      return root.graph();
+    },
+    dispose() {
+      return root.dispose();
+    },
+    register(provider, registerOptions = {}) {
+      root.registerProvider(
+        provider,
+        registerOptions.replace === true
+      );
+      return container;
+    },
+    registerMany(providers) {
+      for (const provider of providers) {
+        root.registerProvider(
+          provider,
+          false
+        );
+      }
+      return container;
+    },
+    providers() {
+      return Array.from(
+        root.providersMap.values()
+      );
+    }
+  };
+  for (const provider of options.providers ?? []) {
+    root.registerProvider(
+      provider,
+      false
+    );
+  }
+  return container;
+}
+var ScopeImpl = class _ScopeImpl {
+  constructor(name, parent) {
+    this.name = name;
+    this.parent = parent;
+    if (parent) {
+      this.root = parent.root;
+      parent.children.add(this);
+    }
+  }
+  name;
+  parent;
+  root;
+  providersMap = /* @__PURE__ */ new Map();
+  overrideProviders = /* @__PURE__ */ new Map();
+  singletonCache = /* @__PURE__ */ new Map();
+  scopedCache = /* @__PURE__ */ new Map();
+  disposals = [];
+  children = /* @__PURE__ */ new Set();
+  state = "active";
+  disposePromise;
+  has(token) {
+    assertToken(token);
+    return this.findProvider(token) !== void 0;
+  }
+  resolve(token) {
+    return this.resolveWithPath(
+      token,
+      []
+    );
+  }
+  async optional(token) {
+    if (!this.has(token)) {
+      return void 0;
+    }
+    return this.resolve(token);
+  }
+  createScope(options = {}) {
+    this.assertActive();
+    const scope = new _ScopeImpl(
+      normalizeOptionalName(
+        options.name
+      ) ?? `${this.name}:scope-${this.children.size + 1}`,
+      this
+    );
+    for (const provider of options.overrides ?? []) {
+      scope.registerOverride(
+        provider
+      );
+    }
+    return scope;
+  }
+  graph() {
+    const effective = /* @__PURE__ */ new Map();
+    let current = this;
+    while (current) {
+      for (const [id, provider] of current.overrideProviders) {
+        if (!effective.has(id)) {
+          effective.set(
+            id,
+            {
+              provider,
+              owner: current,
+              overridden: true
+            }
+          );
+        }
+      }
+      current = current.parent;
+    }
+    for (const [id, provider] of this.root.providersMap) {
+      if (!effective.has(id)) {
+        effective.set(
+          id,
+          {
+            provider,
+            owner: this.root,
+            overridden: false
+          }
+        );
+      }
+    }
+    return Array.from(
+      effective.values(),
+      (record) => ({
+        token: record.provider.token,
+        description: record.provider.token.description,
+        lifetime: normalizeLifetime(
+          record.provider.lifetime
+        ),
+        dependencies: (record.provider.dependencies ?? []).map(
+          (dependency) => dependency.description
+        ),
+        overridden: record.overridden
+      })
+    ).sort(
+      (left, right) => left.description.localeCompare(
+        right.description
+      )
+    );
+  }
+  dispose() {
+    if (this.disposePromise) {
+      return this.disposePromise;
+    }
+    if (this.state === "disposed") {
+      return Promise.resolve();
+    }
+    this.disposePromise = this.disposeInternal();
+    return this.disposePromise;
+  }
+  registerProvider(provider, replace) {
+    this.assertActive();
+    if (this.parent) {
+      throw new Error(
+        "BCP Container: providers can only be registered on the root container. Use scope overrides for child scopes."
+      );
+    }
+    validateProvider(provider);
+    const id = provider.token.id;
+    if (this.providersMap.has(id) && !replace) {
+      throw new Error(
+        `BCP Container: service "${provider.token.description}" is already registered.`
+      );
+    }
+    if (replace && this.hasResolved(id)) {
+      throw new Error(
+        `BCP Container: service "${provider.token.description}" cannot be replaced after it has been resolved.`
+      );
+    }
+    this.providersMap.set(
+      id,
+      provider
+    );
+  }
+  registerOverride(provider) {
+    validateProvider(provider);
+    const id = provider.token.id;
+    if (this.overrideProviders.has(id)) {
+      throw new Error(
+        `BCP Container: scope override for "${provider.token.description}" is already registered.`
+      );
+    }
+    this.overrideProviders.set(
+      id,
+      provider
+    );
+  }
+  async resolveWithPath(token, path) {
+    this.assertActive();
+    assertToken(token);
+    if (path.some(
+      (item) => item.id === token.id
+    )) {
+      throw new ServiceResolutionError(
+        token,
+        `Circular dependency detected: ${[
+          ...path,
+          token
+        ].map(
+          (item) => item.description
+        ).join(" -> ")}.`
+      );
+    }
+    const record = this.findProvider(token);
+    if (!record) {
+      throw new ServiceNotFoundError(
+        token
+      );
+    }
+    const lifetime = normalizeLifetime(
+      record.provider.lifetime
+    );
+    const cache = lifetime === "singleton" ? record.owner.singletonCache : lifetime === "scoped" ? this.scopedCache : void 0;
+    const existing = cache?.get(token.id);
+    if (existing) {
+      return existing;
+    }
+    const resolution = this.instantiate(
+      record.provider,
+      [
+        ...path,
+        token
+      ],
+      lifetime,
+      record.owner
+    );
+    cache?.set(
+      token.id,
+      resolution
+    );
+    try {
+      return await resolution;
+    } catch (error) {
+      cache?.delete(token.id);
+      if (error instanceof ServiceNotFoundError || error instanceof ServiceResolutionError) {
+        throw error;
+      }
+      throw new ServiceResolutionError(
+        token,
+        error instanceof Error ? error.message : String(error),
+        error
+      );
+    }
+  }
+  async instantiate(provider, path, lifetime, providerOwner) {
+    const dependencies = await Promise.all(
+      (provider.dependencies ?? []).map(
+        (dependency) => this.resolveWithPath(
+          dependency,
+          path
+        )
+      )
+    );
+    const context = {
+      scope: this,
+      resolve: (dependency) => this.resolveWithPath(
+        dependency,
+        path
+      ),
+      optional: async (dependency) => {
+        if (!this.has(dependency)) {
+          return void 0;
+        }
+        return this.resolveWithPath(
+          dependency,
+          path
+        );
+      }
+    };
+    const value = await provider.factory(
+      context,
+      dependencies
+    );
+    if (provider.dispose) {
+      const disposalOwner = lifetime === "singleton" ? providerOwner : this;
+      disposalOwner.disposals.push({
+        provider,
+        value
+      });
+    }
+    return value;
+  }
+  findProvider(token) {
+    let current = this;
+    while (current) {
+      const override = current.overrideProviders.get(
+        token.id
+      );
+      if (override) {
+        return {
+          provider: override,
+          owner: current,
+          overridden: true
+        };
+      }
+      current = current.parent;
+    }
+    const provider = this.root.providersMap.get(
+      token.id
+    );
+    if (!provider) {
+      return void 0;
+    }
+    return {
+      provider,
+      owner: this.root,
+      overridden: false
+    };
+  }
+  async disposeInternal() {
+    this.state = "disposing";
+    const errors = [];
+    for (const child of Array.from(
+      this.children
+    ).reverse()) {
+      try {
+        await child.dispose();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    for (const record of [...this.disposals].reverse()) {
+      if (!record.provider.dispose) {
+        continue;
+      }
+      try {
+        await record.provider.dispose(
+          record.value
+        );
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    this.disposals.length = 0;
+    this.singletonCache.clear();
+    this.scopedCache.clear();
+    this.children.clear();
+    this.parent?.children.delete(this);
+    this.state = "disposed";
+    if (errors.length > 0) {
+      throw new ServiceDisposalError(
+        errors
+      );
+    }
+  }
+  hasResolved(id) {
+    if (this.singletonCache.has(id) || this.scopedCache.has(id)) {
+      return true;
+    }
+    for (const child of this.children) {
+      if (child.hasResolved(id)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  assertActive() {
+    if (this.state !== "active") {
+      throw new Error(
+        `BCP Container: scope "${this.name}" is ${this.state}.`
+      );
+    }
+  }
+};
+function validateProvider(provider) {
+  if (!provider || typeof provider !== "object") {
+    throw new TypeError(
+      "BCP Container: provider must be an object."
+    );
+  }
+  assertToken(provider.token);
+  if (typeof provider.factory !== "function") {
+    throw new TypeError(
+      `BCP Container: provider "${provider.token.description}" must define factory().`
+    );
+  }
+  normalizeLifetime(
+    provider.lifetime
+  );
+  assertDependencies(
+    provider.dependencies ?? []
+  );
+  if (provider.dispose !== void 0 && typeof provider.dispose !== "function") {
+    throw new TypeError(
+      `BCP Container: provider "${provider.token.description}" dispose must be a function.`
+    );
+  }
+}
+function assertToken(token) {
+  if (!token || typeof token !== "object" || typeof token.id !== "symbol" || typeof token.description !== "string" || token.description.trim() === "") {
+    throw new TypeError(
+      "BCP Container: invalid service token. Use createServiceToken()."
+    );
+  }
+}
+function assertDependencies(dependencies) {
+  if (!Array.isArray(dependencies)) {
+    throw new TypeError(
+      "BCP Container: provider dependencies must be an array."
+    );
+  }
+  for (const dependency of dependencies) {
+    assertToken(dependency);
+  }
+}
+function normalizeLifetime(lifetime) {
+  const normalized = lifetime ?? "singleton";
+  if (normalized !== "singleton" && normalized !== "scoped" && normalized !== "transient") {
+    throw new TypeError(
+      "BCP Container: service lifetime must be singleton, scoped or transient."
+    );
+  }
+  return normalized;
+}
+function normalizeName(value, label) {
+  if (typeof value !== "string") {
+    throw new TypeError(
+      `BCP Container: ${label} must be a string.`
+    );
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new TypeError(
+      `BCP Container: ${label} cannot be empty.`
+    );
+  }
+  if (normalized.length > 256 || /[\r\n]/.test(normalized)) {
+    throw new TypeError(
+      `BCP Container: ${label} must be at most 256 characters without line breaks.`
+    );
+  }
+  return normalized;
+}
+function normalizeOptionalName(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return normalizeName(
+    value,
+    "scope name"
+  );
+}
+export {
+  ServiceDisposalError,
+  ServiceNotFoundError,
+  ServiceResolutionError,
+  createServiceContainer,
+  createServiceToken,
+  provideClass,
+  provideFactory,
+  provideValue
+};

package/packages/client/src/container.ts

@@ -0,0 +1,24 @@
+export {
+    createServiceContainer,
+    createServiceToken,
+    provideClass,
+    provideFactory,
+    provideValue,
+    ServiceDisposalError,
+    ServiceNotFoundError,
+    ServiceResolutionError,
+
+    type ServiceContainer,
+    type ServiceContainerOptions,
+    type ServiceDependencyValues,
+    type ServiceFactoryContext,
+    type ServiceGraphNode,
+    type ServiceLifetime,
+    type ServiceProvider,
+    type ServiceProviderOptions,
+    type ServiceScope,
+    type ServiceScopeOptions,
+    type ServiceScopeState,
+    type ServiceToken,
+    type ServiceTokenValue,
+} from "../../server/src/container.js";