@decohere/http 0.0.1-dev.126 → 0.0.1-dev.5

package/commonjs/src/auth/ability.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get ADMIN_ROLE () {
-        return ADMIN_ROLE;
-    },
-    get createPrincipalFromPayload () {
-        return createPrincipalFromPayload;
-    },
-    get defineAbilitiesFor () {
-        return defineAbilitiesFor;
-    }
-});
-const _ability = require("@casl/ability");
-const ADMIN_ROLE = "admin";
-function defineAbilitiesFor(principal) {
-    const { can, build } = new _ability.AbilityBuilder(_ability.createMongoAbility);
-    if (principal.roles?.includes(ADMIN_ROLE)) {
-        can("manage", "all");
-        return build();
-    }
-    for (const scope of principal.scopes ?? []){
-        const [action, subject] = scope.split(":");
-        if (action && subject) can(action, subject);
-    }
-    return build();
-}
-function createPrincipalFromPayload(payload) {
-    const sub = typeof payload.sub === "string" ? payload.sub : "";
-    const fromScopeClaim = typeof payload.scope === "string" ? payload.scope.split(" ").filter(Boolean) : Array.isArray(payload.scopes) ? payload.scopes.filter((s)=>typeof s === "string") : [];
-    const fromPermissions = Array.isArray(payload.permissions) ? payload.permissions.filter((s)=>typeof s === "string") : [];
-    const merged = [
-        ...new Set([
-            ...fromScopeClaim,
-            ...fromPermissions
-        ])
-    ];
-    const scopes = merged.length > 0 ? merged : undefined;
-    const roles = Array.isArray(payload.roles) ? payload.roles.filter((r)=>typeof r === "string") : undefined;
-    return {
-        ...payload,
-        sub,
-        roles: roles && roles.length > 0 ? roles : undefined,
-        scopes
-    };
-}

package/commonjs/src/auth/auth.config.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AuthConfig", {
-    enumerable: true,
-    get: function() {
-        return AuthConfig;
-    }
-});
-class AuthConfig {
-    /** OIDC discovery URL — the issuer base URL, e.g. https://accounts.google.com.
-	 *  The framework appends `/.well-known/openid-configuration` automatically.
-	 *  Use this instead of `jwksUrl` for any standard OIDC-compliant IdP.
-	 */ discoveryUrl;
-    /** JWKS endpoint URL (RS256 / ES256 via remote key set). */ jwksUrl;
-    /** PEM-encoded public key or JWK JSON string (RS256 / ES256 static key). */ publicKey;
-    algorithms;
-    /** Shared secret for HS256. */ secret;
-    /** Issuer claim to validate (all non-devStatic variants). */ issuer;
-    /** Audience claim to validate (all non-devStatic variants). */ audience;
-    /** Static principal injected for every request (development only). */ devStatic;
-}

package/commonjs/src/auth/auth.extensions.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get ADMIN_ROLE () {
-        return _ability.ADMIN_ROLE;
-    },
-    get BuilderExtensions () {
-        return BuilderExtensions;
-    },
-    get createPrincipalFromPayload () {
-        return _ability.createPrincipalFromPayload;
-    },
-    get defineAbilitiesFor () {
-        return _ability.defineAbilitiesFor;
-    }
-});
-const _extensibility = require("@decohere/core/extensibility");
-const _builder = require("../builder/builder.js");
-const _const = require("../const.js");
-const _ability = require("./ability.js");
-const _authconfig = require("./auth.config.js");
-const _authtypes = require("./auth.types.js");
-const _caslauthorizationservice = require("./casl-authorization.service.js");
-const _tokenservice = require("./token-service.js");
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-class BuilderExtensions {
-    static withAuth(builder, abilityFactory = _ability.defineAbilitiesFor, options) {
-        builder.registerPreBuildStep(async (configService, containerBuilder)=>{
-            const authConfig = await configService.get(_authconfig.AuthConfig);
-            const tokenConfig = toTokenServiceConfig(authConfig);
-            const tokenService = new _tokenservice.TokenService(tokenConfig, options?.principalMapper);
-            containerBuilder.registerSingleton(_const.TokenServiceToken, tokenService);
-            containerBuilder.registerSingleton(_const.AuthorizationServiceToken, new _caslauthorizationservice.CaslAuthorizationService(abilityFactory, tokenService));
-        });
-        return builder;
-    }
-}
-_ts_decorate([
-    (0, _extensibility.extension)(_builder.Builder),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _builder.Builder === "undefined" ? Object : _builder.Builder,
-        typeof AbilityFactory === "undefined" ? Object : AbilityFactory,
-        typeof WithAuthOptions === "undefined" ? Object : WithAuthOptions
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], BuilderExtensions, "withAuth", null);
-function toTokenServiceConfig(config) {
-    // Prefer real verification strategies over devStatic so a leftover
-    // development block cannot disable OIDC/JWKS in any environment.
-    if (config.discoveryUrl != null) {
-        (0, _authtypes.assertNonEmptyAudience)(config.audience);
-        return {
-            discoveryUrl: config.discoveryUrl,
-            audience: config.audience
-        };
-    }
-    if (config.jwksUrl != null) {
-        (0, _authtypes.assertNonEmptyAudience)(config.audience);
-        return {
-            jwksUrl: config.jwksUrl,
-            issuer: config.issuer,
-            audience: config.audience
-        };
-    }
-    if (config.publicKey != null) {
-        (0, _authtypes.assertNonEmptyAudience)(config.audience);
-        return {
-            publicKey: config.publicKey,
-            algorithms: config.algorithms,
-            issuer: config.issuer,
-            audience: config.audience
-        };
-    }
-    if (config.secret != null) {
-        (0, _authtypes.assertNonEmptyAudience)(config.audience);
-        return {
-            secret: config.secret,
-            issuer: config.issuer,
-            audience: config.audience
-        };
-    }
-    if (config.devStatic != null) {
-        (0, _authtypes.assertDevStaticAllowed)();
-        return {
-            devStatic: config.devStatic
-        };
-    }
-    throw new Error("AuthConfig must specify one of: discoveryUrl, jwksUrl, publicKey, secret, or devStatic");
-}

package/commonjs/src/auth/auth.types.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get assertDevStaticAllowed () {
-        return assertDevStaticAllowed;
-    },
-    get assertNonEmptyAudience () {
-        return assertNonEmptyAudience;
-    },
-    get isDevStaticConfig () {
-        return isDevStaticConfig;
-    },
-    get isDevelopmentNodeEnv () {
-        return isDevelopmentNodeEnv;
-    },
-    get isDiscoveryConfig () {
-        return isDiscoveryConfig;
-    },
-    get isJwksConfig () {
-        return isJwksConfig;
-    },
-    get isPublicKeyConfig () {
-        return isPublicKeyConfig;
-    },
-    get isSecretConfig () {
-        return isSecretConfig;
-    }
-});
-function isDiscoveryConfig(config) {
-    return "discoveryUrl" in config;
-}
-function isDevStaticConfig(config) {
-    return "devStatic" in config;
-}
-function isJwksConfig(config) {
-    return "jwksUrl" in config;
-}
-function isPublicKeyConfig(config) {
-    return "publicKey" in config;
-}
-function isSecretConfig(config) {
-    return "secret" in config;
-}
-function isDevelopmentNodeEnv(nodeEnv = process.env.NODE_ENV) {
-    const env = nodeEnv?.toLowerCase();
-    return env === "development" || env === "dev";
-}
-function assertDevStaticAllowed(nodeEnv = process.env.NODE_ENV) {
-    if (!isDevelopmentNodeEnv(nodeEnv)) {
-        throw new Error(`AuthConfig.devStatic is only allowed when NODE_ENV is "development" or "dev" (got ${JSON.stringify(nodeEnv ?? "")}).`);
-    }
-}
-function assertNonEmptyAudience(audience) {
-    if (typeof audience !== "string" || audience.trim().length === 0) {
-        throw new Error(`JWT audience must be a non-empty string (got ${JSON.stringify(audience)}). ` + "Empty audience disables aud validation and accepts tokens minted for other APIs.");
-    }
-}

package/commonjs/src/auth/casl-authorization.service.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CaslAuthorizationService", {
-    enumerable: true,
-    get: function() {
-        return CaslAuthorizationService;
-    }
-});
-const _anviltypes = require("../routing/anvil.types.js");
-class CaslAuthorizationService {
-    factory;
-    tokenService;
-    constructor(factory, tokenService){
-        this.factory = factory;
-        this.tokenService = tokenService;
-    }
-    async authorizeRequest(request, action, subject) {
-        const principal = await this.authenticateRequest(request);
-        await this.authorize(principal, action, subject);
-        return principal;
-    }
-    async authenticateRequest(request) {
-        if (!this.tokenService) {
-            throw new Error("CaslAuthorizationService requires a TokenService to authenticate requests. Register it via .withAuth().");
-        }
-        return this.tokenService.verifyRequest(request);
-    }
-    async authorize(principal, action, subject) {
-        const ability = this.factory(principal);
-        if (ability.cannot(action, subject)) {
-            throw new _anviltypes.ForbiddenError(`Cannot perform "${action}" on "${subject}"`);
-        }
-    }
-}

package/commonjs/src/auth/index.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./ability.js"), exports);
-_export_star(require("./auth.config.js"), exports);
-_export_star(require("./auth.types.js"), exports);
-_export_star(require("./casl-authorization.service.js"), exports);
-_export_star(require("./principal-provider.js"), exports);
-_export_star(require("./token-service.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/auth/principal-provider.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "PrincipalProvider", {
-    enumerable: true,
-    get: function() {
-        return PrincipalProvider;
-    }
-});
-class PrincipalProvider {
-    _principal;
-    get currentPrincipal() {
-        return this._principal;
-    }
-    setPrincipal(principal) {
-        this._principal = principal;
-    }
-}

package/commonjs/src/auth/safe-outbound-url.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "assertSafeOutboundUrl", {
-    enumerable: true,
-    get: function() {
-        return assertSafeOutboundUrl;
-    }
-});
-const _promises = require("node:dns/promises");
-const _nodenet = require("node:net");
-async function assertSafeOutboundUrl(raw, label) {
-    let url;
-    try {
-        url = new URL(raw);
-    } catch  {
-        throw new Error(`Invalid ${label}: ${raw}`);
-    }
-    if (url.protocol !== "https:" && url.protocol !== "http:") {
-        throw new Error(`${label} must use http or https (got ${url.protocol})`);
-    }
-    if (url.username || url.password) {
-        throw new Error(`${label} must not include credentials`);
-    }
-    const hostname = url.hostname.replace(/^\[|\]$/g, "");
-    if (isBlockedHostname(hostname)) {
-        throw new Error(`${label} host is not allowed (${hostname})`);
-    }
-    const ips = await resolveIps(hostname);
-    const allowLoopback = isLoopbackAllowed();
-    for (const ip of ips){
-        if (isBlockedIp(ip, allowLoopback)) {
-            throw new Error(`${label} resolves to a blocked address (${ip})`);
-        }
-    }
-    if (url.protocol === "http:") {
-        const loopbackOnly = isLoopbackHostname(hostname) || ips.length > 0 && ips.every((ip)=>isLoopbackIp(ip));
-        if (!loopbackOnly || !allowLoopback) {
-            throw new Error(`${label} must use https unless targeting loopback in development/test`);
-        }
-    }
-    return url;
-}
-function isLoopbackAllowed() {
-    const env = process.env.NODE_ENV ?? "";
-    return env === "development" || env === "dev" || env === "test";
-}
-function isLoopbackHostname(hostname) {
-    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
-}
-function isBlockedHostname(hostname) {
-    const lower = hostname.toLowerCase();
-    return lower === "metadata.google.internal" || lower === "metadata" || lower.endsWith(".metadata.google.internal");
-}
-async function resolveIps(hostname) {
-    if ((0, _nodenet.isIP)(hostname)) {
-        return [
-            hostname
-        ];
-    }
-    const results = await (0, _promises.lookup)(hostname, {
-        all: true,
-        verbatim: true
-    });
-    return results.map((r)=>r.address);
-}
-function isLoopbackIp(ip) {
-    const list = new _nodenet.BlockList();
-    list.addSubnet("127.0.0.0", 8, "ipv4");
-    list.addAddress("::1", "ipv6");
-    list.addSubnet("::ffff:127.0.0.0", 104, "ipv6");
-    return list.check(ip);
-}
-function isBlockedIp(ip, allowLoopback) {
-    if (allowLoopback && isLoopbackIp(ip)) {
-        return false;
-    }
-    const list = new _nodenet.BlockList();
-    // IPv4 special-use / private
-    list.addSubnet("0.0.0.0", 8, "ipv4");
-    list.addSubnet("10.0.0.0", 8, "ipv4");
-    list.addSubnet("100.64.0.0", 10, "ipv4"); // shared address space
-    list.addSubnet("127.0.0.0", 8, "ipv4");
-    list.addSubnet("169.254.0.0", 16, "ipv4"); // link-local / cloud metadata
-    list.addSubnet("172.16.0.0", 12, "ipv4");
-    list.addSubnet("192.168.0.0", 16, "ipv4");
-    list.addSubnet("198.18.0.0", 15, "ipv4"); // benchmarking
-    // IPv6
-    list.addAddress("::1", "ipv6");
-    list.addSubnet("fc00::", 7, "ipv6"); // unique local
-    list.addSubnet("fe80::", 10, "ipv6"); // link-local
-    if (list.check(ip)) {
-        return true;
-    }
-    // Mapped IPv4 inside IPv6 (::ffff:a.b.c.d)
-    const mapped = ip.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
-    if (mapped) {
-        return isBlockedIp(mapped[1], allowLoopback);
-    }
-    return false;
-}

package/commonjs/src/auth/token-service.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "TokenService", {
-    enumerable: true,
-    get: function() {
-        return TokenService;
-    }
-});
-const _jose = require("jose");
-const _anviltypes = require("../routing/anvil.types.js");
-const _ability = require("./ability.js");
-const _authtypes = require("./auth.types.js");
-const _safeoutboundurl = require("./safe-outbound-url.js");
-class TokenService {
-    config;
-    principalMapper;
-    /** Lazily resolved JWKS set when using OIDC discovery. */ discoveryJwks;
-    discoveryIssuer;
-    /** Remote key set for `jwksUrl` mode, created once so jose can cache the keys. */ configuredJwks;
-    constructor(config, principalMapper){
-        if ((0, _authtypes.isDevStaticConfig)(config)) {
-            (0, _authtypes.assertDevStaticAllowed)();
-        } else {
-            (0, _authtypes.assertNonEmptyAudience)(config.audience);
-        }
-        this.config = config;
-        this.principalMapper = principalMapper;
-    }
-    async verifyRequest(request) {
-        const authHeader = request.headers.authorization;
-        if (!authHeader) {
-            throw new _anviltypes.UnauthorizedError("Missing Authorization header");
-        }
-        const spaceIdx = authHeader.indexOf(" ");
-        if (spaceIdx === -1) {
-            throw new _anviltypes.UnauthorizedError("Malformed Authorization header");
-        }
-        const scheme = authHeader.slice(0, spaceIdx);
-        if (scheme !== "Bearer") {
-            throw new _anviltypes.UnauthorizedError(`Unsupported authorization scheme: ${scheme}`);
-        }
-        const credentials = authHeader.slice(spaceIdx + 1);
-        return this.verify(credentials);
-    }
-    async verify(credentials) {
-        if ((0, _authtypes.isDevStaticConfig)(this.config)) {
-            return this.config.devStatic;
-        }
-        try {
-            const { key, issuer, audience } = await this.resolveVerificationContext();
-            // jose's overloads don't accept Key | JWKS-getter as a union; runtime does.
-            const { payload } = await (0, _jose.jwtVerify)(credentials, key, {
-                issuer,
-                audience
-            });
-            return this.mapPrincipal(payload);
-        } catch (err) {
-            throw new _anviltypes.UnauthorizedError(err instanceof Error ? err.message : "Token verification failed");
-        }
-    }
-    /**
-	 * Resolve how to verify tokens for the configured strategy:
-	 * - OIDC discovery → fetch JWKS + issuer from `/.well-known/openid-configuration`
-	 * - explicit JWKS URL → remote key set + configured issuer/audience
-	 * - public key / shared secret → static key material + configured issuer/audience
-	 */ async resolveVerificationContext() {
-        if ((0, _authtypes.isDiscoveryConfig)(this.config)) {
-            const { jwks, issuer } = await this.resolveOidcDiscovery();
-            return {
-                key: jwks,
-                issuer,
-                audience: this.config.audience
-            };
-        }
-        if ((0, _authtypes.isJwksConfig)(this.config)) {
-            this.configuredJwks ??= (0, _jose.createRemoteJWKSet)(await (0, _safeoutboundurl.assertSafeOutboundUrl)(this.config.jwksUrl, "jwksUrl"));
-            return {
-                key: this.configuredJwks,
-                issuer: this.config.issuer,
-                audience: this.config.audience
-            };
-        }
-        return {
-            key: await this.getStaticKey(),
-            issuer: this.config.issuer,
-            audience: this.config.audience
-        };
-    }
-    async resolveOidcDiscovery() {
-        if (this.discoveryJwks && this.discoveryIssuer) {
-            return {
-                jwks: this.discoveryJwks,
-                issuer: this.discoveryIssuer
-            };
-        }
-        const { discoveryUrl } = this.config;
-        await (0, _safeoutboundurl.assertSafeOutboundUrl)(discoveryUrl, "discoveryUrl");
-        const resp = await fetch(`${discoveryUrl.replace(/\/$/, "")}/.well-known/openid-configuration`, {
-            redirect: "error"
-        });
-        if (!resp.ok) {
-            throw new Error(`OIDC discovery failed for ${discoveryUrl}: HTTP ${resp.status}`);
-        }
-        const doc = await resp.json();
-        if (typeof doc.jwks_uri !== "string" || doc.jwks_uri.length === 0) {
-            throw new Error(`OIDC discovery for ${discoveryUrl} did not return jwks_uri`);
-        }
-        const jwksUrl = await (0, _safeoutboundurl.assertSafeOutboundUrl)(doc.jwks_uri, "jwks_uri");
-        this.discoveryIssuer = doc.issuer;
-        this.discoveryJwks = (0, _jose.createRemoteJWKSet)(jwksUrl);
-        return {
-            jwks: this.discoveryJwks,
-            issuer: this.discoveryIssuer
-        };
-    }
-    /**
-	 * Sign a payload and return a JWT string.
-	 * Only available when configured with a SecretConfig (HS256).
-	 * For RS256/ES256 issuance, the caller is responsible for key management.
-	 */ async sign(payload, expiresIn = "1h") {
-        if (!(0, _authtypes.isSecretConfig)(this.config)) {
-            throw new Error("TokenService.sign() requires SecretConfig (shared secret / HS256)");
-        }
-        const key = new TextEncoder().encode(this.config.secret);
-        return new _jose.SignJWT(payload).setProtectedHeader({
-            alg: "HS256"
-        }).setIssuedAt().setIssuer(this.config.issuer ?? "").setAudience(this.config.audience ?? "").setExpirationTime(expiresIn).sign(key);
-    }
-    async getStaticKey() {
-        if ((0, _authtypes.isPublicKeyConfig)(this.config)) {
-            const cfg = this.config;
-            const trimmed = cfg.publicKey.trim();
-            if (trimmed.startsWith("{")) {
-                const jwk = JSON.parse(trimmed);
-                return (0, _jose.importJWK)(jwk);
-            }
-            return (0, _jose.importSPKI)(trimmed, cfg.algorithms?.[0] ?? "RS256");
-        }
-        if ((0, _authtypes.isSecretConfig)(this.config)) {
-            const enc = new TextEncoder().encode(this.config.secret);
-            return enc;
-        }
-        throw new Error("Invalid TokenService configuration");
-    }
-    mapPrincipal(payload) {
-        if (this.principalMapper) return this.principalMapper(payload);
-        return (0, _ability.createPrincipalFromPayload)(payload);
-    }
-}

package/commonjs/src/builder/builder.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Builder", {
-    enumerable: true,
-    get: function() {
-        return Builder;
-    }
-});
-const _crucible = require("@decohere/crucible");
-const _configuration = require("@decohere/core/configuration");
-const _scribe = require("@decohere/scribe");
-const _app = require("../app/app.js");
-const _const = require("../const.js");
-const _hostedservicehost = require("../hosting/hosted-service-host.js");
-class Builder {
-    static create(options) {
-        return new Builder(options);
-    }
-    containerBuilder;
-    applicationName;
-    logger = _scribe.scribe.logger("name");
-    userServices = [];
-    preBuildSteps = [];
-    postBuildSteps = [];
-    hostedServices = new _hostedservicehost.HostedServiceHost();
-    constructor(options){
-        this.containerBuilder = options?.containerBuilder ?? new _crucible.ServiceContainerBuilder();
-        this.applicationName = options?.applicationName;
-    }
-    withServices(userServices) {
-        this.userServices.push(userServices);
-        return this;
-    }
-    /**
-	 * Run {@link HostedService}s for the life of the app: started in this order before the HTTP
-	 * server listens, stopped in reverse when the app stops (including SIGTERM and Flux reboots).
-	 * Each is registered as a singleton, so other services can inject it by its class.
-	 */ withHostedService(...types) {
-        for (const type of types)this.containerBuilder.registerSingleton(type);
-        this.hostedServices.add(...types);
-        return this;
-    }
-    registerPreBuildStep(step) {
-        this.preBuildSteps.push(step);
-    }
-    registerPostBuildStep(step) {
-        this.postBuildSteps.push(step);
-    }
-    async buildAndStart(type) {
-        const app = await this.build(type);
-        await app.start();
-        this.logger.info("App started...");
-        return app;
-    }
-    async build(type) {
-        this.logger.info("Building App...");
-        this.configureUserServices();
-        this.configureApp(type);
-        await this.runPreBuildSteps(this.containerBuilder);
-        const container = this.containerBuilder.build();
-        await this.runPostBuildSteps(container);
-        const app = this.resolveApp(container, type);
-        return app;
-    }
-    configureUserServices() {
-        for (const userService of this.userServices){
-            userService(this.containerBuilder);
-        }
-    }
-    async runPreBuildSteps(containerBuilder) {
-        if (this.preBuildSteps.length === 0) {
-            return;
-        }
-        const container = containerBuilder.build();
-        const config = container.resolve(_configuration.ConfigurationServiceToken);
-        for (const step of this.preBuildSteps){
-            await step(config, containerBuilder);
-        }
-    }
-    async runPostBuildSteps(container) {
-        for (const step of this.postBuildSteps){
-            await step(container);
-        }
-    }
-    configureApp(type) {
-        this.containerBuilder.registerSingleton(_const.HostedServiceHostToken, this.hostedServices);
-        this.containerBuilder.registerSingleton(type ?? _app.App);
-    }
-    resolveApp(container, type) {
-        const app = type ? container.resolve(type) : container.resolve(_app.App);
-        return app;
-    }
-}