@slopware/sloppy-darwin-x64 0.1.0-alpha.0

package/stdlib/sloppy/internal/services.js

@@ -0,0 +1,690 @@
+import { isPromiseLike } from "./shared.js";
+import { Cache, isCache } from "../cache.js";
+import { Http } from "../http.js";
+import { Redis } from "../redis.js";
+
+function validateServiceToken(token) {
+    if (typeof token === "string" && token.length !== 0) {
+        return;
+    }
+    if (
+        token !== null &&
+        typeof token === "object" &&
+        typeof token.__sloppyHttpClientToken === "string" &&
+        token.__sloppyHttpClientToken.length !== 0
+    ) {
+        return;
+    }
+    if (
+        token !== null &&
+        typeof token === "object" &&
+        typeof token.__sloppyRedisToken === "string" &&
+        token.__sloppyRedisToken.length !== 0
+    ) {
+        return;
+    }
+    throw new TypeError("Sloppy service token must be a non-empty string or supported typed service token.");
+}
+
+function serviceTokenDisplay(token) {
+    return normalizeServiceToken(token);
+}
+
+function normalizeServiceToken(token) {
+    validateServiceToken(token);
+    if (typeof token === "string") {
+        return token;
+    }
+    return token.__sloppyHttpClientToken ?? token.__sloppyRedisToken;
+}
+
+function cacheServiceToken(name = "default") {
+    return Cache.token(name);
+}
+
+function validateCacheInstance(cache) {
+    if (!isCache(cache) || typeof cache.stats !== "function") {
+        throw new TypeError("Sloppy services.addCache expects a Cache instance.");
+    }
+}
+
+function validateWebhooksDescriptor(descriptor) {
+    if (
+        descriptor === null ||
+        typeof descriptor !== "object" ||
+        descriptor.__sloppyWebhooksOutboxRegistration !== true ||
+        typeof descriptor.token !== "string" ||
+        descriptor.token.length === 0 ||
+        typeof descriptor.createService !== "function"
+    ) {
+        throw new TypeError("Sloppy services.addWebhooks expects Webhooks.outbox(...).");
+    }
+    return descriptor;
+}
+
+function createServicesBuilder(guard) {
+    const registrations = new Map();
+    let currentModule = null;
+
+    function addRegistration(token, registration) {
+        guard.assertMutable();
+        const normalizedToken = normalizeServiceToken(token);
+
+        if (registrations.has(normalizedToken)) {
+            throw new Error(`Sloppy service '${serviceTokenDisplay(normalizedToken)}' is already registered.`);
+        }
+
+        registrations.set(normalizedToken, {
+            ...registration,
+            module: currentModule,
+        });
+        return services;
+    }
+
+    const services = {
+        addSingleton(token, factoryOrValue) {
+            const registration = {
+                lifetime: "singleton",
+                factory: typeof factoryOrValue === "function" ? factoryOrValue : null,
+                value: factoryOrValue,
+                initialized: typeof factoryOrValue !== "function",
+            };
+
+            return addRegistration(token, registration);
+        },
+
+        addCache(cacheOrName, nameOrOptions = undefined) {
+            guard.assertMutable();
+            const cache = typeof cacheOrName === "string"
+                ? Cache.redis(cacheOrName, nameOrOptions ?? {})
+                : cacheOrName;
+            validateCacheInstance(cache);
+            const cacheName = typeof cacheOrName === "string" ? cache.name : nameOrOptions ?? cache.name ?? "default";
+            return addRegistration(cacheServiceToken(cacheName), {
+                lifetime: "singleton",
+                factory: null,
+                value: cache,
+                initialized: true,
+            });
+        },
+
+
+        addRedis(clientOrName, options = undefined) {
+            guard.assertMutable();
+
+            const client = typeof clientOrName === "string"
+                ? Redis.client(clientOrName, options ?? {})
+                : clientOrName;
+            const registration = client?.__sloppyRedisRegistration;
+            if (registration === undefined) {
+                throw new TypeError("Sloppy services.addRedis expects Redis.client or a client name with options.");
+            }
+
+            addRegistration(registration.token, {
+                lifetime: "singleton",
+                initialized: true,
+                value: client,
+            });
+            return services;
+        },
+        addTransient(token, factory) {
+            guard.assertMutable();
+
+            if (typeof factory !== "function") {
+                throw new TypeError("Sloppy transient service factory must be a function.");
+            }
+
+            return addRegistration(token, {
+                lifetime: "transient",
+                factory,
+            });
+        },
+
+        addScoped(token, factory) {
+            guard.assertMutable();
+
+            if (typeof factory !== "function") {
+                throw new TypeError("Sloppy scoped service factory must be a function.");
+            }
+
+            return addRegistration(token, {
+                lifetime: "scoped",
+                factory,
+            });
+        },
+
+        addHttpClient(clientOrName, options = undefined) {
+            guard.assertMutable();
+
+            const client = typeof clientOrName === "string"
+                ? Http.client(clientOrName, options ?? {})
+                : clientOrName;
+            const registration = client?.__sloppyHttpClientRegistration;
+            if (registration === undefined) {
+                throw new TypeError("Sloppy services.addHttpClient expects Http.client, Http.typedClient, or a client name with options.");
+            }
+
+            const namedToken = normalizeServiceToken(registration.namedToken ?? registration.token);
+            if (!registrations.has(namedToken)) {
+                addRegistration(namedToken, {
+                    lifetime: "singleton",
+                    initialized: false,
+                    factory(scope) {
+                        return registration.createNamed(scope.config);
+                    },
+                });
+            } else if (registration.kind !== "typed") {
+                throw new Error(`Sloppy service '${serviceTokenDisplay(namedToken)}' is already registered.`);
+            }
+
+            if (registration.kind === "typed") {
+                addRegistration(registration.token, {
+                    lifetime: "transient",
+                    factory(scope) {
+                        return registration.createTyped(scope.get(namedToken));
+                    },
+                });
+            }
+
+            return services;
+        },
+
+        addWebhooks(descriptor) {
+            guard.assertMutable();
+
+            const registration = validateWebhooksDescriptor(descriptor);
+            return addRegistration(registration.token, {
+                lifetime: "singleton",
+                initialized: false,
+                factory(scope) {
+                    return registration.createService(scope);
+                },
+                webhooks: typeof registration.__sloppyPlanMetadata === "function"
+                    ? registration.__sloppyPlanMetadata()
+                    : undefined,
+            });
+        },
+
+        __snapshot() {
+            return new Map(Array.from(registrations.entries(), ([token, registration]) => [
+                token,
+                { ...registration },
+            ]));
+        },
+
+        __runInModule(moduleName, callback) {
+            const previousModule = currentModule;
+            currentModule = moduleName;
+
+            try {
+                return callback(services);
+            } finally {
+                currentModule = previousModule;
+            }
+        },
+    };
+
+    return Object.freeze(services);
+}
+
+
+function combineCleanupErrors(primary, cleanup) {
+    return new AggregateError([primary, cleanup], "Sloppy cleanup failed after a handler error.");
+}
+
+function cleanupAfterSuccess(result, cleanup) {
+    const cleanupResult = cleanup();
+    if (isPromiseLike(cleanupResult)) {
+        return Promise.resolve(cleanupResult).then(() => result);
+    }
+    return result;
+}
+
+function cleanupAfterFailure(error, cleanup) {
+    try {
+        const cleanupResult = cleanup();
+        if (isPromiseLike(cleanupResult)) {
+            return Promise.resolve(cleanupResult).then(
+                () => {
+                    throw error;
+                },
+                (cleanupError) => {
+                    throw combineCleanupErrors(error, cleanupError);
+                },
+            );
+        }
+    } catch (cleanupError) {
+        throw combineCleanupErrors(error, cleanupError);
+    }
+    throw error;
+}
+
+function finishWithCleanup(result, cleanup) {
+    if (isPromiseLike(result)) {
+        return Promise.resolve(result).then(
+            (value) => cleanupAfterSuccess(value, cleanup),
+            (error) => cleanupAfterFailure(error, cleanup),
+        );
+    }
+    return cleanupAfterSuccess(result, cleanup);
+}
+
+function createServiceProvider(registrations, capabilities, config = undefined) {
+    const normalizedRegistrations = new Map();
+    const originalTokens = new Map();
+    for (const [token, registration] of registrations.entries()) {
+        const normalizedToken = normalizeServiceToken(token);
+        if (normalizedRegistrations.has(normalizedToken)) {
+            throw new Error(`Sloppy service '${serviceTokenDisplay(normalizedToken)}' is already registered; '${serviceTokenDisplay(token)}' conflicts with '${serviceTokenDisplay(originalTokens.get(normalizedToken))}'.`);
+        }
+        normalizedRegistrations.set(normalizedToken, registration);
+        originalTokens.set(normalizedToken, token);
+    }
+    registrations = normalizedRegistrations;
+    const singletonDisposables = [];
+    let providerDisposed = false;
+
+    function disposeValue(value) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (typeof value[Symbol.dispose] === "function") {
+            return value[Symbol.dispose]();
+        }
+        if (typeof value.dispose === "function") {
+            return value.dispose();
+        }
+        if (typeof value.close === "function") {
+            return value.close();
+        }
+        return undefined;
+    }
+
+    function disposalError(errors, message) {
+        if (errors.length === 1) {
+            return errors[0];
+        }
+        return new AggregateError(errors, message);
+    }
+
+    function disposeValues(values, message) {
+        const errors = [];
+        const pending = [];
+        for (const value of values) {
+            try {
+                const result = disposeValue(value);
+                if (isPromiseLike(result)) {
+                    pending.push(Promise.resolve(result).catch((error) => {
+                        errors.push(error);
+                    }));
+                }
+            } catch (error) {
+                errors.push(error);
+            }
+        }
+
+        if (pending.length === 0) {
+            if (errors.length !== 0) {
+                throw disposalError(errors, message);
+            }
+            return undefined;
+        }
+
+        return Promise.all(pending).then(() => {
+            if (errors.length !== 0) {
+                throw disposalError(errors, message);
+            }
+            return undefined;
+        });
+    }
+
+    function createRootScope() {
+        const resolving = [];
+        const resolvingLifetimes = [];
+        const scope = Object.freeze({
+            capabilities,
+            config,
+            get(token) {
+                return resolve(scope, token);
+            },
+            tryGet(token) {
+                const normalizedToken = normalizeServiceToken(token);
+                if (providerDisposed) {
+                    throw new Error("Sloppy service provider is disposed.");
+                }
+                if (!registrations.has(normalizedToken)) {
+                    return undefined;
+                }
+                return resolve(scope, normalizedToken);
+            },
+            __disposed() {
+                return false;
+            },
+            __hasScoped() {
+                return false;
+            },
+            __getScoped() {
+                return undefined;
+            },
+            __setScoped() {
+                throw new Error("Sloppy root service scope cannot store scoped services.");
+            },
+            __trackTransient(value) {
+                singletonDisposables.push(value);
+            },
+            __resolving() {
+                return resolving;
+            },
+            __resolvingLifetimes() {
+                return resolvingLifetimes;
+            },
+            __pushResolving(token, lifetime) {
+                resolving.push(token);
+                resolvingLifetimes.push(lifetime);
+            },
+            __popResolving() {
+                resolving.pop();
+                resolvingLifetimes.pop();
+            },
+        });
+        return scope;
+    }
+
+    function resolve(scope, token) {
+        const normalizedToken = normalizeServiceToken(token);
+
+        if (providerDisposed) {
+            throw new Error("Sloppy service provider is disposed.");
+        }
+
+        if (scope.__disposed()) {
+            throw new Error("Sloppy service scope is disposed.");
+        }
+
+        if (!registrations.has(normalizedToken)) {
+            throw new Error(`Sloppy service '${serviceTokenDisplay(normalizedToken)}' is not registered.`);
+        }
+
+        const registration = registrations.get(normalizedToken);
+
+        if (scope.__resolving().includes(normalizedToken)) {
+            throw new Error(`Sloppy service circular dependency detected: ${[...scope.__resolving(), normalizedToken].map(serviceTokenDisplay).join(" -> ")}.`);
+        }
+
+        if (
+            registration.lifetime === "scoped" &&
+            scope.__resolvingLifetimes().includes("singleton")
+        ) {
+            throw new Error(`Sloppy singleton service cannot depend on scoped service '${serviceTokenDisplay(normalizedToken)}'.`);
+        }
+
+        if (registration.lifetime === "singleton") {
+            if (!registration.initialized) {
+                rootScope.__pushResolving(normalizedToken, "singleton");
+                try {
+                    registration.value = registration.factory(rootScope);
+                    singletonDisposables.push(registration.value);
+                } finally {
+                    rootScope.__popResolving();
+                }
+                registration.initialized = true;
+            }
+
+            return registration.value;
+        }
+
+        if (registration.lifetime === "scoped") {
+            if (!scope.__hasScoped(normalizedToken)) {
+                scope.__pushResolving(normalizedToken, "scoped");
+                try {
+                    scope.__setScoped(normalizedToken, registration.factory(scope));
+                } finally {
+                    scope.__popResolving();
+                }
+            }
+            return scope.__getScoped(normalizedToken);
+        }
+
+        scope.__pushResolving(normalizedToken, "transient");
+        try {
+            const value = registration.factory(scope);
+            scope.__trackTransient(value);
+            return value;
+        } finally {
+            scope.__popResolving();
+        }
+    }
+
+    function createScope() {
+        const scopedValues = new Map();
+        const scopeOwnedValues = [];
+        const resolving = [];
+        const resolvingLifetimes = [];
+        let disposed = false;
+
+        const scope = Object.freeze({
+            capabilities,
+            config,
+            get(token) {
+                return resolve(scope, token);
+            },
+            tryGet(token) {
+                const normalizedToken = normalizeServiceToken(token);
+                if (providerDisposed) {
+                    throw new Error("Sloppy service provider is disposed.");
+                }
+                if (disposed) {
+                    throw new Error("Sloppy service scope is disposed.");
+                }
+                if (!registrations.has(normalizedToken)) {
+                    return undefined;
+                }
+                return resolve(scope, normalizedToken);
+            },
+            dispose() {
+                if (disposed) {
+                    return undefined;
+                }
+                disposed = true;
+                return disposeValues([...scopeOwnedValues].reverse(), "Sloppy service scope disposal failed.");
+            },
+            __disposed() {
+                return disposed;
+            },
+            __hasScoped(token) {
+                return scopedValues.has(token);
+            },
+            __getScoped(token) {
+                return scopedValues.get(token);
+            },
+            __setScoped(token, value) {
+                scopedValues.set(token, value);
+                scopeOwnedValues.push(value);
+            },
+            __trackTransient(value) {
+                scopeOwnedValues.push(value);
+            },
+            __resolving() {
+                return resolving;
+            },
+            __resolvingLifetimes() {
+                return resolvingLifetimes;
+            },
+            __pushResolving(token, lifetime) {
+                resolving.push(token);
+                resolvingLifetimes.push(lifetime);
+            },
+            __popResolving() {
+                resolving.pop();
+                resolvingLifetimes.pop();
+            },
+        });
+
+        return scope;
+    }
+
+    const rootScope = createRootScope();
+
+    function addHttpClient(clientOrName, options = undefined) {
+        if (providerDisposed) {
+            throw new Error("Sloppy service provider is disposed.");
+        }
+        const client = typeof clientOrName === "string"
+            ? Http.client(clientOrName, options ?? {})
+            : clientOrName;
+        const registration = client?.__sloppyHttpClientRegistration;
+        if (registration === undefined) {
+            throw new TypeError("Sloppy services.addHttpClient expects Http.client, Http.typedClient, or a client name with options.");
+        }
+
+        const namedToken = normalizeServiceToken(registration.namedToken ?? registration.token);
+        if (!registrations.has(namedToken)) {
+            registrations.set(namedToken, {
+                lifetime: "singleton",
+                initialized: false,
+                factory(scope) {
+                    return registration.createNamed(scope.config);
+                },
+            });
+        } else if (registration.kind !== "typed") {
+            throw new Error(`Sloppy service '${serviceTokenDisplay(namedToken)}' is already registered.`);
+        }
+
+        if (registration.kind === "typed") {
+            const typedToken = normalizeServiceToken(registration.token);
+            if (registrations.has(typedToken)) {
+                throw new Error(`Sloppy service '${serviceTokenDisplay(typedToken)}' is already registered.`);
+            }
+            registrations.set(typedToken, {
+                lifetime: "transient",
+                factory(scope) {
+                    return registration.createTyped(scope.get(namedToken));
+                },
+            });
+        }
+
+        return provider;
+    }
+
+    function addWebhooks(descriptor) {
+        if (providerDisposed) {
+            throw new Error("Sloppy service provider is disposed.");
+        }
+        const registration = validateWebhooksDescriptor(descriptor);
+        if (registrations.has(registration.token)) {
+            throw new Error(`Sloppy service '${registration.token}' is already registered.`);
+        }
+        registrations.set(registration.token, {
+            lifetime: "singleton",
+            initialized: false,
+            factory(scope) {
+                return registration.createService(scope);
+            },
+            webhooks: typeof registration.__sloppyPlanMetadata === "function"
+                ? registration.__sloppyPlanMetadata()
+                : undefined,
+        });
+        return provider;
+    }
+
+    function addRedis(clientOrName, options = undefined) {
+        if (providerDisposed) {
+            throw new Error("Sloppy service provider is disposed.");
+        }
+        const client = typeof clientOrName === "string"
+            ? Redis.client(clientOrName, options ?? {})
+            : clientOrName;
+        const registration = client?.__sloppyRedisRegistration;
+        if (registration === undefined) {
+            throw new TypeError("Sloppy services.addRedis expects Redis.client or a client name with options.");
+        }
+        const token = normalizeServiceToken(registration.token);
+        if (registrations.has(token)) {
+            throw new Error(`Sloppy service '${serviceTokenDisplay(token)}' is already registered.`);
+        }
+        registrations.set(token, {
+            lifetime: "singleton",
+            initialized: true,
+            value: client,
+        });
+        singletonDisposables.push(client);
+        return provider;
+    }
+
+    const provider = Object.freeze({
+        addHttpClient,
+        addWebhooks,
+        addRedis,
+        get(token) {
+            const normalizedToken = normalizeServiceToken(token);
+            if (providerDisposed) {
+                throw new Error("Sloppy service provider is disposed.");
+            }
+            const registration = registrations.get(normalizedToken);
+            if (registration === undefined) {
+                throw new Error(`Sloppy service '${serviceTokenDisplay(normalizedToken)}' is not registered.`);
+            }
+            if (registration.lifetime !== "singleton") {
+                throw new Error(`Sloppy root service resolution only supports singleton services; create a scope to resolve '${serviceTokenDisplay(normalizedToken)}'.`);
+            }
+            return resolve(rootScope, normalizedToken);
+        },
+
+        tryGet(token) {
+            const normalizedToken = normalizeServiceToken(token);
+            if (providerDisposed) {
+                throw new Error("Sloppy service provider is disposed.");
+            }
+            const registration = registrations.get(normalizedToken);
+            if (registration === undefined) {
+                return undefined;
+            }
+            if (registration.lifetime !== "singleton") {
+                throw new Error(`Sloppy root service resolution only supports singleton services; create a scope to resolve '${serviceTokenDisplay(normalizedToken)}'.`);
+            }
+            return resolve(rootScope, normalizedToken);
+        },
+
+        createScope,
+
+        addCache(cacheOrName, nameOrOptions = undefined) {
+            if (providerDisposed) {
+                throw new Error("Sloppy service provider is disposed.");
+            }
+            const cache = typeof cacheOrName === "string"
+                ? Cache.redis(cacheOrName, nameOrOptions ?? {})
+                : cacheOrName;
+            validateCacheInstance(cache);
+            const token = cacheServiceToken(typeof cacheOrName === "string" ? cache.name : nameOrOptions ?? cache.name ?? "default");
+            if (registrations.has(token)) {
+                throw new Error(`Sloppy service '${token}' is already registered.`);
+            }
+            registrations.set(token, {
+                lifetime: "singleton",
+                factory: null,
+                value: cache,
+                initialized: true,
+            });
+            singletonDisposables.push(cache);
+            return provider;
+        },
+
+        dispose() {
+            if (providerDisposed) {
+                return undefined;
+            }
+            providerDisposed = true;
+            return disposeValues(singletonDisposables.reverse(), "Sloppy service provider disposal failed.");
+        },
+    });
+
+    return provider;
+}
+
+export {
+    cleanupAfterFailure,
+    createServiceProvider,
+    createServicesBuilder,
+    finishWithCleanup,
+    validateServiceToken,
+};