@webiny/api-core 6.4.5 → 6.6.0-alpha.0

package/features/requestContext/RequestTenantLoader.d.ts

@@ -0,0 +1,18 @@
+import { RequestTenantLoader as Abstraction } from "./abstractions.js";
+import type { IRawTenantId } from "./abstractions.js";
+import type { ITenantContext } from "../../features/tenancy/TenantContext/abstractions.js";
+import type { IGetTenantByIdUseCase } from "../../features/tenancy/GetTenantById/abstractions.js";
+/**
+ * LOAD step: reads the raw tenant id (set by the transport's EXTRACT step into RawTenantId),
+ * resolves the Tenant, and sets TenantContext. Transport-agnostic.
+ */
+export declare class RequestTenantLoaderImpl implements Abstraction.Interface {
+    private tenantContext;
+    private getTenantById;
+    private rawTenantId;
+    constructor(tenantContext: ITenantContext, getTenantById: IGetTenantByIdUseCase, rawTenantId: IRawTenantId);
+    establish(): Promise<void>;
+}
+export declare const RequestTenantLoader: typeof RequestTenantLoaderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRequestTenantLoader>;
+};

package/features/requestContext/RequestTenantLoader.js

@@ -0,0 +1,52 @@
+import { RawTenantId, RequestTenantLoader } from "./abstractions.js";
+import { TenantContext } from "../tenancy/TenantContext/index.js";
+import { GetTenantByIdUseCase } from "../tenancy/GetTenantById/index.js";
+const DEFAULT_TENANT_ID = "root";
+const createBootstrapRootTenant = ()=>{
+    const now = new Date().toISOString();
+    return {
+        id: DEFAULT_TENANT_ID,
+        name: "Root",
+        description: "",
+        status: "enabled",
+        isInstalled: false,
+        settings: {
+            name: {
+                full: "Root",
+                slug: "root"
+            },
+            social: {},
+            favicon: {},
+            logo: {}
+        },
+        tags: [],
+        parent: null,
+        createdOn: now,
+        savedOn: now
+    };
+};
+class RequestTenantLoaderImpl {
+    constructor(tenantContext, getTenantById, rawTenantId){
+        this.tenantContext = tenantContext;
+        this.getTenantById = getTenantById;
+        this.rawTenantId = rawTenantId;
+    }
+    async establish() {
+        const resolvedId = this.rawTenantId.get() || DEFAULT_TENANT_ID;
+        const result = await this.getTenantById.execute(resolvedId);
+        if (result.isOk()) return void this.tenantContext.setTenant(result.value);
+        if (resolvedId === DEFAULT_TENANT_ID) return void this.tenantContext.setTenant(createBootstrapRootTenant());
+        console.warn(`[RequestTenantLoader] Tenant "${resolvedId}" not found.`);
+    }
+}
+const RequestTenantLoader_RequestTenantLoader = RequestTenantLoader.createImplementation({
+    implementation: RequestTenantLoaderImpl,
+    dependencies: [
+        TenantContext,
+        GetTenantByIdUseCase,
+        RawTenantId
+    ]
+});
+export { RequestTenantLoaderImpl, RequestTenantLoader_RequestTenantLoader as RequestTenantLoader };
+
+//# sourceMappingURL=RequestTenantLoader.js.map

package/features/requestContext/RequestTenantLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/requestContext/RequestTenantLoader.js","sources":["../../../src/features/requestContext/RequestTenantLoader.ts"],"sourcesContent":["import { RequestTenantLoader as Abstraction, RawTenantId } from \"./abstractions.js\";\nimport type { IRawTenantId } from \"./abstractions.js\";\nimport { TenantContext } from \"~/features/tenancy/TenantContext/index.js\";\nimport type { ITenantContext } from \"~/features/tenancy/TenantContext/abstractions.js\";\nimport { GetTenantByIdUseCase } from \"~/features/tenancy/GetTenantById/index.js\";\nimport type { IGetTenantByIdUseCase } from \"~/features/tenancy/GetTenantById/abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nconst DEFAULT_TENANT_ID = \"root\";\n\n/**\n * A minimal in-memory root tenant used only before the system is installed, when the real root\n * tenant record doesn't exist yet. It keeps the request pipeline + GraphQL schema build functional\n * (nothing dereferences a null tenant) so the install mutation can run and create the real root.\n * Once installed, getTenantById returns the persisted record and this is never used.\n */\nconst createBootstrapRootTenant = (): Tenant => {\n    const now = new Date().toISOString();\n    return {\n        id: DEFAULT_TENANT_ID,\n        name: \"Root\",\n        description: \"\",\n        status: \"enabled\",\n        isInstalled: false,\n        settings: {\n            name: { full: \"Root\", slug: \"root\" },\n            social: {},\n            favicon: {},\n            logo: {}\n        } as any,\n        tags: [],\n        parent: null,\n        createdOn: now,\n        savedOn: now\n    };\n};\n\n/**\n * LOAD step: reads the raw tenant id (set by the transport's EXTRACT step into RawTenantId),\n * resolves the Tenant, and sets TenantContext. Transport-agnostic.\n */\nexport class RequestTenantLoaderImpl implements Abstraction.Interface {\n    constructor(\n        private tenantContext: ITenantContext,\n        private getTenantById: IGetTenantByIdUseCase,\n        private rawTenantId: IRawTenantId\n    ) {}\n\n    async establish(): Promise<void> {\n        const resolvedId = this.rawTenantId.get() || DEFAULT_TENANT_ID;\n        const result = await this.getTenantById.execute(resolvedId);\n        if (result.isOk()) {\n            this.tenantContext.setTenant(result.value);\n            return;\n        }\n\n        // Fresh, not-yet-installed environment: the root tenant record doesn't exist yet. Establish a\n        // bootstrap root so the request pipeline + GraphQL schema build work and the install mutation\n        // can create the real root tenant. Only ever taken for the root tenant pre-install.\n        if (resolvedId === DEFAULT_TENANT_ID) {\n            this.tenantContext.setTenant(createBootstrapRootTenant());\n            return;\n        }\n\n        console.warn(`[RequestTenantLoader] Tenant \"${resolvedId}\" not found.`);\n    }\n}\n\nexport const RequestTenantLoader = Abstraction.createImplementation({\n    implementation: RequestTenantLoaderImpl,\n    dependencies: [TenantContext, GetTenantByIdUseCase, RawTenantId]\n});\n"],"names":["DEFAULT_TENANT_ID","createBootstrapRootTenant","now","Date","RequestTenantLoaderImpl","tenantContext","getTenantById","rawTenantId","resolvedId","result","console","RequestTenantLoader","Abstraction","TenantContext","GetTenantByIdUseCase","RawTenantId"],"mappings":";;;AAQA,MAAMA,oBAAoB;AAQ1B,MAAMC,4BAA4B;IAC9B,MAAMC,MAAM,IAAIC,OAAO,WAAW;IAClC,OAAO;QACH,IAAIH;QACJ,MAAM;QACN,aAAa;QACb,QAAQ;QACR,aAAa;QACb,UAAU;YACN,MAAM;gBAAE,MAAM;gBAAQ,MAAM;YAAO;YACnC,QAAQ,CAAC;YACT,SAAS,CAAC;YACV,MAAM,CAAC;QACX;QACA,MAAM,EAAE;QACR,QAAQ;QACR,WAAWE;QACX,SAASA;IACb;AACJ;AAMO,MAAME;IACT,YACYC,aAA6B,EAC7BC,aAAoC,EACpCC,WAAyB,CACnC;aAHUF,aAAa,GAAbA;aACAC,aAAa,GAAbA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,YAA2B;QAC7B,MAAMC,aAAa,IAAI,CAAC,WAAW,CAAC,GAAG,MAAMR;QAC7C,MAAMS,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACD;QAChD,IAAIC,OAAO,IAAI,IAAI,YACf,IAAI,CAAC,aAAa,CAAC,SAAS,CAACA,OAAO,KAAK;QAO7C,IAAID,eAAeR,mBAAmB,YAClC,IAAI,CAAC,aAAa,CAAC,SAAS,CAACC;QAIjCS,QAAQ,IAAI,CAAC,CAAC,8BAA8B,EAAEF,WAAW,YAAY,CAAC;IAC1E;AACJ;AAEO,MAAMG,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgBR;IAChB,cAAc;QAACS;QAAeC;QAAsBC;KAAY;AACpE"}

package/features/requestContext/abstractions.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Per-request holder for the raw tenant id EXTRACTED by the transport (e.g. the `x-tenant` header
+ * of an API Gateway event, the bucket name of an S3 event, or `payload.tenant` of a background
+ * task). The transport-specific EXTRACT step sets this; the transport-agnostic LOAD step
+ * (RequestTenantLoader) reads it, resolves the Tenant, and sets TenantContext.
+ */
+export interface IRawTenantId {
+    get(): string | null;
+    set(id: string | null): void;
+}
+export declare const RawTenantId: import("@webiny/di").Abstraction<IRawTenantId>;
+export declare namespace RawTenantId {
+    type Interface = IRawTenantId;
+}
+/**
+ * Per-request holder for the raw auth token EXTRACTED by the transport (e.g. the `Authorization`
+ * bearer header or an auth cookie of an API Gateway event). Only token-based transports set this;
+ * the transport-agnostic LOAD step (RequestIdentityLoader) reads it, authenticates it, and
+ * sets IdentityContext. A null/absent value authenticates as anonymous.
+ *
+ * Note: non-token transports (S3, background tasks) never set this — S3 has no user identity, and
+ * background-task identity is derived from `task.createdBy` after the task is fetched.
+ */
+export interface IRawAuthToken {
+    get(): string | null;
+    set(token: string | null): void;
+}
+export declare const RawAuthToken: import("@webiny/di").Abstraction<IRawAuthToken>;
+export declare namespace RawAuthToken {
+    type Interface = IRawAuthToken;
+}
+/**
+ * LOAD step: authenticates the token held by RawAuthToken and sets IdentityContext. Fully
+ * transport-agnostic — transports only EXTRACT the token into RawAuthToken.
+ */
+export interface IRequestIdentityLoader {
+    establish(): Promise<void>;
+}
+export declare const RequestIdentityLoader: import("@webiny/di").Abstraction<IRequestIdentityLoader>;
+export declare namespace RequestIdentityLoader {
+    type Interface = IRequestIdentityLoader;
+}
+/**
+ * LOAD step: resolves the Tenant for the id held by RawTenantId and sets TenantContext. Fully
+ * transport-agnostic — transports only EXTRACT the id into RawTenantId.
+ */
+export interface IRequestTenantLoader {
+    establish(): Promise<void>;
+}
+export declare const RequestTenantLoader: import("@webiny/di").Abstraction<IRequestTenantLoader>;
+export declare namespace RequestTenantLoader {
+    type Interface = IRequestTenantLoader;
+}

package/features/requestContext/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+const RawTenantId = createAbstraction("RequestContext/RawTenantId");
+const RawAuthToken = createAbstraction("RequestContext/RawAuthToken");
+const RequestIdentityLoader = createAbstraction("RequestContext/RequestIdentityLoader");
+const RequestTenantLoader = createAbstraction("RequestContext/RequestTenantLoader");
+export { RawAuthToken, RawTenantId, RequestIdentityLoader, RequestTenantLoader };
+
+//# sourceMappingURL=abstractions.js.map

package/features/requestContext/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/requestContext/abstractions.js","sources":["../../../src/features/requestContext/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\n/**\n * Per-request holder for the raw tenant id EXTRACTED by the transport (e.g. the `x-tenant` header\n * of an API Gateway event, the bucket name of an S3 event, or `payload.tenant` of a background\n * task). The transport-specific EXTRACT step sets this; the transport-agnostic LOAD step\n * (RequestTenantLoader) reads it, resolves the Tenant, and sets TenantContext.\n */\nexport interface IRawTenantId {\n    get(): string | null;\n    set(id: string | null): void;\n}\n\nexport const RawTenantId = createAbstraction<IRawTenantId>(\"RequestContext/RawTenantId\");\n\nexport namespace RawTenantId {\n    export type Interface = IRawTenantId;\n}\n\n/**\n * Per-request holder for the raw auth token EXTRACTED by the transport (e.g. the `Authorization`\n * bearer header or an auth cookie of an API Gateway event). Only token-based transports set this;\n * the transport-agnostic LOAD step (RequestIdentityLoader) reads it, authenticates it, and\n * sets IdentityContext. A null/absent value authenticates as anonymous.\n *\n * Note: non-token transports (S3, background tasks) never set this — S3 has no user identity, and\n * background-task identity is derived from `task.createdBy` after the task is fetched.\n */\nexport interface IRawAuthToken {\n    get(): string | null;\n    set(token: string | null): void;\n}\n\nexport const RawAuthToken = createAbstraction<IRawAuthToken>(\"RequestContext/RawAuthToken\");\n\nexport namespace RawAuthToken {\n    export type Interface = IRawAuthToken;\n}\n\n/**\n * LOAD step: authenticates the token held by RawAuthToken and sets IdentityContext. Fully\n * transport-agnostic — transports only EXTRACT the token into RawAuthToken.\n */\nexport interface IRequestIdentityLoader {\n    establish(): Promise<void>;\n}\n\nexport const RequestIdentityLoader = createAbstraction<IRequestIdentityLoader>(\n    \"RequestContext/RequestIdentityLoader\"\n);\n\nexport namespace RequestIdentityLoader {\n    export type Interface = IRequestIdentityLoader;\n}\n\n/**\n * LOAD step: resolves the Tenant for the id held by RawTenantId and sets TenantContext. Fully\n * transport-agnostic — transports only EXTRACT the id into RawTenantId.\n */\nexport interface IRequestTenantLoader {\n    establish(): Promise<void>;\n}\n\nexport const RequestTenantLoader = createAbstraction<IRequestTenantLoader>(\n    \"RequestContext/RequestTenantLoader\"\n);\n\nexport namespace RequestTenantLoader {\n    export type Interface = IRequestTenantLoader;\n}\n"],"names":["RawTenantId","createAbstraction","RawAuthToken","RequestIdentityLoader","RequestTenantLoader"],"mappings":";AAaO,MAAMA,cAAcC,kBAAgC;AAoBpD,MAAMC,eAAeD,kBAAiC;AActD,MAAME,wBAAwBF,kBACjC;AAeG,MAAMG,sBAAsBH,kBAC/B"}

package/features/requestContext/feature.d.ts

@@ -0,0 +1,11 @@
+import type { Container } from "@webiny/di";
+/**
+ * Registers the request-context pieces:
+ * - RawTenantId / RawAuthToken: per-request holders that the transport's EXTRACT step writes to.
+ * - RequestIdentityLoader / RequestTenantLoader: transport-agnostic LOAD steps that read
+ *   the holders and set IdentityContext / TenantContext.
+ */
+export declare const RequestContextFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/requestContext/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { RawTenantId } from "./RawTenantId.js";
+import { RawAuthToken } from "./RawAuthToken.js";
+import { RequestIdentityLoader } from "./RequestIdentityLoader.js";
+import { RequestTenantLoader } from "./RequestTenantLoader.js";
+const RequestContextFeature = createFeature({
+    name: "RequestContext",
+    register (container) {
+        container.register(RawTenantId).inSingletonScope();
+        container.register(RawAuthToken).inSingletonScope();
+        container.register(RequestIdentityLoader);
+        container.register(RequestTenantLoader);
+    }
+});
+export { RequestContextFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/requestContext/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/requestContext/feature.js","sources":["../../../src/features/requestContext/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { RawTenantId } from \"./RawTenantId.js\";\nimport { RawAuthToken } from \"./RawAuthToken.js\";\nimport { RequestIdentityLoader } from \"./RequestIdentityLoader.js\";\nimport { RequestTenantLoader } from \"./RequestTenantLoader.js\";\n\n/**\n * Registers the request-context pieces:\n * - RawTenantId / RawAuthToken: per-request holders that the transport's EXTRACT step writes to.\n * - RequestIdentityLoader / RequestTenantLoader: transport-agnostic LOAD steps that read\n *   the holders and set IdentityContext / TenantContext.\n */\nexport const RequestContextFeature = createFeature({\n    name: \"RequestContext\",\n    register(container: Container) {\n        // Singleton so the value the transport's EXTRACT step sets is the same instance the LOAD\n        // establisher reads. Registered per request (RequestContextFeature runs per-request), so it's\n        // singleton *within the request container* — a fresh holder per request.\n        container.register(RawTenantId).inSingletonScope();\n        container.register(RawAuthToken).inSingletonScope();\n        container.register(RequestIdentityLoader);\n        container.register(RequestTenantLoader);\n    }\n});\n"],"names":["RequestContextFeature","createFeature","container","RawTenantId","RawAuthToken","RequestIdentityLoader","RequestTenantLoader"],"mappings":";;;;;AAaO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAoB;QAIzBA,UAAU,QAAQ,CAACC,aAAa,gBAAgB;QAChDD,UAAU,QAAQ,CAACE,cAAc,gBAAgB;QACjDF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;IACvB;AACJ"}

package/features/requestContext/index.d.ts

@@ -0,0 +1,2 @@
+export { RawTenantId, RawAuthToken, RequestIdentityLoader, RequestTenantLoader } from "./abstractions.js";
+export { RequestContextFeature } from "./feature.js";

package/features/requestContext/index.js

@@ -0,0 +1,2 @@
+export { RawAuthToken, RawTenantId, RequestIdentityLoader, RequestTenantLoader } from "./abstractions.js";
+export { RequestContextFeature } from "./feature.js";

package/features/security/apiKeys/ApiKeyAuthenticator.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from "../../../features/logger/index.js";
+import type { IAuthenticator } from "../../../features/security/authentication/Authenticator/abstractions.js";
+import type { IApiKeysRepository } from "./shared/abstractions.js";
+import type { IdentityData } from "../../../features/security/IdentityContext/Identity.js";
+declare class ApiKeyAuthenticatorImpl implements IAuthenticator {
+    private repository;
+    private logger;
+    constructor(repository: IApiKeysRepository, logger: Logger.Interface);
+    authenticate(token: string): Promise<IdentityData | null>;
+}
+export declare const ApiKeyAuthenticator: typeof ApiKeyAuthenticatorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAuthenticator>;
+};
+export {};

package/features/security/apiKeys/ApiKeyAuthenticator.js

@@ -0,0 +1,36 @@
+import { Authenticator } from "../authentication/Authenticator/abstractions.js";
+import { ApiKeysRepository } from "./shared/abstractions.js";
+import { Logger } from "../../logger/index.js";
+class ApiKeyAuthenticatorImpl {
+    constructor(repository, logger){
+        this.repository = repository;
+        this.logger = logger;
+    }
+    async authenticate(token) {
+        if ("string" != typeof token || !token.startsWith("wat_")) return null;
+        const result = await this.repository.getByToken(token);
+        if (!result.isOk()) {
+            this.logger.warn({
+                error: result.error
+            }, "API key authentication failed; request will proceed as anonymous.");
+            return null;
+        }
+        const apiKey = result.value;
+        return {
+            id: apiKey.id,
+            displayName: apiKey.name,
+            type: "api-key",
+            permissions: apiKey.permissions
+        };
+    }
+}
+const ApiKeyAuthenticator = Authenticator.createImplementation({
+    implementation: ApiKeyAuthenticatorImpl,
+    dependencies: [
+        ApiKeysRepository,
+        Logger
+    ]
+});
+export { ApiKeyAuthenticator };
+
+//# sourceMappingURL=ApiKeyAuthenticator.js.map

package/features/security/apiKeys/ApiKeyAuthenticator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/security/apiKeys/ApiKeyAuthenticator.js","sources":["../../../../src/features/security/apiKeys/ApiKeyAuthenticator.ts"],"sourcesContent":["import { Authenticator } from \"~/features/security/authentication/Authenticator/abstractions.js\";\nimport { ApiKeysRepository } from \"./shared/abstractions.js\";\nimport { Logger } from \"~/features/logger/index.js\";\nimport type { IAuthenticator } from \"~/features/security/authentication/Authenticator/abstractions.js\";\nimport type { IApiKeysRepository } from \"./shared/abstractions.js\";\nimport type { IdentityData } from \"~/features/security/IdentityContext/Identity.js\";\n\nclass ApiKeyAuthenticatorImpl implements IAuthenticator {\n    constructor(\n        private repository: IApiKeysRepository,\n        private logger: Logger.Interface\n    ) {}\n\n    async authenticate(token: string): Promise<IdentityData | null> {\n        if (typeof token !== \"string\" || !token.startsWith(\"wat_\")) {\n            return null;\n        }\n        const result = await this.repository.getByToken(token);\n        if (!result.isOk()) {\n            // The token looked like an API key (\"wat_\") but could not be resolved. Log it — otherwise\n            // this degrades silently to an anonymous request (which is what made the tenant-ordering\n            // bug so hard to find). A genuine unknown/revoked key logs here too, which is acceptable.\n            this.logger.warn(\n                { error: result.error },\n                \"API key authentication failed; request will proceed as anonymous.\"\n            );\n            return null;\n        }\n        const apiKey = result.value;\n        return {\n            id: apiKey.id,\n            displayName: apiKey.name,\n            type: \"api-key\",\n            permissions: apiKey.permissions\n        };\n    }\n}\n\nexport const ApiKeyAuthenticator = Authenticator.createImplementation({\n    implementation: ApiKeyAuthenticatorImpl,\n    dependencies: [ApiKeysRepository, Logger]\n});\n"],"names":["ApiKeyAuthenticatorImpl","repository","logger","token","result","apiKey","ApiKeyAuthenticator","Authenticator","ApiKeysRepository","Logger"],"mappings":";;;AAOA,MAAMA;IACF,YACYC,UAA8B,EAC9BC,MAAwB,CAClC;aAFUD,UAAU,GAAVA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,aAAaC,KAAa,EAAgC;QAC5D,IAAI,AAAiB,YAAjB,OAAOA,SAAsB,CAACA,MAAM,UAAU,CAAC,SAC/C,OAAO;QAEX,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,CAACD;QAChD,IAAI,CAACC,OAAO,IAAI,IAAI;YAIhB,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ;gBAAE,OAAOA,OAAO,KAAK;YAAC,GACtB;YAEJ,OAAO;QACX;QACA,MAAMC,SAASD,OAAO,KAAK;QAC3B,OAAO;YACH,IAAIC,OAAO,EAAE;YACb,aAAaA,OAAO,IAAI;YACxB,MAAM;YACN,aAAaA,OAAO,WAAW;QACnC;IACJ;AACJ;AAEO,MAAMC,sBAAsBC,cAAc,oBAAoB,CAAC;IAClE,gBAAgBP;IAChB,cAAc;QAACQ;QAAmBC;KAAO;AAC7C"}

package/features/security/apiKeys/ApiKeyAuthorizer.d.ts

@@ -0,0 +1,10 @@
+import type { IAuthorizer } from "../../../features/security/authorization/Authorizer/abstractions.js";
+import type { Identity } from "../../../features/security/IdentityContext/Identity.js";
+import type { SecurityPermission } from "../../../types/security.js";
+declare class ApiKeyAuthorizerImpl implements IAuthorizer {
+    authorize(identity: Identity): Promise<SecurityPermission[] | null>;
+}
+export declare const ApiKeyAuthorizer: typeof ApiKeyAuthorizerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAuthorizer>;
+};
+export {};

package/features/security/apiKeys/ApiKeyAuthorizer.js

@@ -0,0 +1,15 @@
+import { Authorizer } from "../authorization/Authorizer/abstractions.js";
+class ApiKeyAuthorizerImpl {
+    async authorize(identity) {
+        if (!identity || "api-key" !== identity.type) return null;
+        const permissions = identity.permissions;
+        return Array.isArray(permissions) ? permissions : [];
+    }
+}
+const ApiKeyAuthorizer = Authorizer.createImplementation({
+    implementation: ApiKeyAuthorizerImpl,
+    dependencies: []
+});
+export { ApiKeyAuthorizer };
+
+//# sourceMappingURL=ApiKeyAuthorizer.js.map

package/features/security/apiKeys/ApiKeyAuthorizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/security/apiKeys/ApiKeyAuthorizer.js","sources":["../../../../src/features/security/apiKeys/ApiKeyAuthorizer.ts"],"sourcesContent":["import { Authorizer } from \"~/features/security/authorization/Authorizer/abstractions.js\";\nimport type { IAuthorizer } from \"~/features/security/authorization/Authorizer/abstractions.js\";\nimport type { Identity } from \"~/features/security/IdentityContext/Identity.js\";\nimport type { SecurityPermission } from \"~/types/security.js\";\n\nclass ApiKeyAuthorizerImpl implements IAuthorizer {\n    async authorize(identity: Identity): Promise<SecurityPermission[] | null> {\n        if (!identity || identity.type !== \"api-key\") {\n            return null;\n        }\n        const permissions = (identity as any).permissions;\n        return Array.isArray(permissions) ? (permissions as SecurityPermission[]) : [];\n    }\n}\n\nexport const ApiKeyAuthorizer = Authorizer.createImplementation({\n    implementation: ApiKeyAuthorizerImpl,\n    dependencies: []\n});\n"],"names":["ApiKeyAuthorizerImpl","identity","permissions","Array","ApiKeyAuthorizer","Authorizer"],"mappings":";AAKA,MAAMA;IACF,MAAM,UAAUC,QAAkB,EAAwC;QACtE,IAAI,CAACA,YAAYA,AAAkB,cAAlBA,SAAS,IAAI,EAC1B,OAAO;QAEX,MAAMC,cAAeD,SAAiB,WAAW;QACjD,OAAOE,MAAM,OAAO,CAACD,eAAgBA,cAAuC,EAAE;IAClF;AACJ;AAEO,MAAME,mBAAmBC,WAAW,oBAAoB,CAAC;IAC5D,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/features/security/apiKeys/feature.js

@@ -8,11 +8,15 @@ import { CreateApiKeyFeature } from "./CreateApiKey/feature.js";
 import { UpdateApiKeyFeature } from "./UpdateApiKey/feature.js";
 import { DeleteApiKeyFeature } from "./DeleteApiKey/feature.js";
 import { ApiKeyProvider } from "./shared/ApiKeyProvider.js";
+import { ApiKeyAuthenticator } from "./ApiKeyAuthenticator.js";
+import { ApiKeyAuthorizer } from "./ApiKeyAuthorizer.js";
 const ApiKeysFeature = createFeature({
     name: "ApiKeys",
     register (container) {
         container.register(ApiKeysRepository).inSingletonScope();
         container.register(ApiKeyProvider).inSingletonScope();
+        container.register(ApiKeyAuthenticator);
+        container.register(ApiKeyAuthorizer);
         GetApiKeyFeature.register(container);
         GetApiKeyByTokenFeature.register(container);
         GetApiKeyBySlugFeature.register(container);

package/features/security/apiKeys/feature.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/security/apiKeys/feature.js","sources":["../../../../src/features/security/apiKeys/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ApiKeysRepository } from \"./shared/ApiKeysRepository.js\";\nimport { GetApiKeyFeature } from \"./GetApiKey/feature.js\";\nimport { GetApiKeyByTokenFeature } from \"./GetApiKeyByToken/feature.js\";\nimport { GetApiKeyBySlugFeature } from \"./GetApiKeyBySlug/feature.js\";\nimport { ListApiKeysFeature } from \"./ListApiKeys/feature.js\";\nimport { CreateApiKeyFeature } from \"./CreateApiKey/feature.js\";\nimport { UpdateApiKeyFeature } from \"./UpdateApiKey/feature.js\";\nimport { DeleteApiKeyFeature } from \"./DeleteApiKey/feature.js\";\nimport { ApiKeyProvider } from \"./shared/ApiKeyProvider.js\";\n\nexport const ApiKeysFeature = createFeature({\n    name: \"ApiKeys\",\n    register(container) {\n        // Register repository in singleton scope\n        container.register(ApiKeysRepository).inSingletonScope();\n        container.register(ApiKeyProvider).inSingletonScope();\n\n        // Register all use cases\n        GetApiKeyFeature.register(container);\n        GetApiKeyByTokenFeature.register(container);\n        GetApiKeyBySlugFeature.register(container);\n        ListApiKeysFeature.register(container);\n        CreateApiKeyFeature.register(container);\n        UpdateApiKeyFeature.register(container);\n        DeleteApiKeyFeature.register(container);\n    }\n});\n"],"names":["ApiKeysFeature","createFeature","container","ApiKeysRepository","ApiKeyProvider","GetApiKeyFeature","GetApiKeyByTokenFeature","GetApiKeyBySlugFeature","ListApiKeysFeature","CreateApiKeyFeature","UpdateApiKeyFeature","DeleteApiKeyFeature"],"mappings":";;;;;;;;;;AAWO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC,mBAAmB,gBAAgB;QACtDD,UAAU,QAAQ,CAACE,gBAAgB,gBAAgB;QAGnDC,iBAAiB,QAAQ,CAACH;QAC1BI,wBAAwB,QAAQ,CAACJ;QACjCK,uBAAuB,QAAQ,CAACL;QAChCM,mBAAmB,QAAQ,CAACN;QAC5BO,oBAAoB,QAAQ,CAACP;QAC7BQ,oBAAoB,QAAQ,CAACR;QAC7BS,oBAAoB,QAAQ,CAACT;IACjC;AACJ"}
+{"version":3,"file":"features/security/apiKeys/feature.js","sources":["../../../../src/features/security/apiKeys/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ApiKeysRepository } from \"./shared/ApiKeysRepository.js\";\nimport { GetApiKeyFeature } from \"./GetApiKey/feature.js\";\nimport { GetApiKeyByTokenFeature } from \"./GetApiKeyByToken/feature.js\";\nimport { GetApiKeyBySlugFeature } from \"./GetApiKeyBySlug/feature.js\";\nimport { ListApiKeysFeature } from \"./ListApiKeys/feature.js\";\nimport { CreateApiKeyFeature } from \"./CreateApiKey/feature.js\";\nimport { UpdateApiKeyFeature } from \"./UpdateApiKey/feature.js\";\nimport { DeleteApiKeyFeature } from \"./DeleteApiKey/feature.js\";\nimport { ApiKeyProvider } from \"./shared/ApiKeyProvider.js\";\nimport { ApiKeyAuthenticator } from \"./ApiKeyAuthenticator.js\";\nimport { ApiKeyAuthorizer } from \"./ApiKeyAuthorizer.js\";\n\nexport const ApiKeysFeature = createFeature({\n    name: \"ApiKeys\",\n    register(container) {\n        // Register repository in singleton scope\n        container.register(ApiKeysRepository).inSingletonScope();\n        container.register(ApiKeyProvider).inSingletonScope();\n        container.register(ApiKeyAuthenticator);\n        container.register(ApiKeyAuthorizer);\n\n        // Register all use cases\n        GetApiKeyFeature.register(container);\n        GetApiKeyByTokenFeature.register(container);\n        GetApiKeyBySlugFeature.register(container);\n        ListApiKeysFeature.register(container);\n        CreateApiKeyFeature.register(container);\n        UpdateApiKeyFeature.register(container);\n        DeleteApiKeyFeature.register(container);\n    }\n});\n"],"names":["ApiKeysFeature","createFeature","container","ApiKeysRepository","ApiKeyProvider","ApiKeyAuthenticator","ApiKeyAuthorizer","GetApiKeyFeature","GetApiKeyByTokenFeature","GetApiKeyBySlugFeature","ListApiKeysFeature","CreateApiKeyFeature","UpdateApiKeyFeature","DeleteApiKeyFeature"],"mappings":";;;;;;;;;;;;AAaO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC,mBAAmB,gBAAgB;QACtDD,UAAU,QAAQ,CAACE,gBAAgB,gBAAgB;QACnDF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QAGnBC,iBAAiB,QAAQ,CAACL;QAC1BM,wBAAwB,QAAQ,CAACN;QACjCO,uBAAuB,QAAQ,CAACP;QAChCQ,mBAAmB,QAAQ,CAACR;QAC5BS,oBAAoB,QAAQ,CAACT;QAC7BU,oBAAoB,QAAQ,CAACV;QAC7BW,oBAAoB,QAAQ,CAACX;IACjC;AACJ"}

package/features/security/authorization/GroupsTeamsAuthorizer/GetPermissionsFromIdentity.d.ts

@@ -13,8 +13,8 @@ declare class GetPermissionsFromGroupsAndTeamsImpl implements PermissionsProcess
     private teamsRepository;
     constructor(wcpContext: WcpContext.Interface, usersRepository: AdminUsersRepository.Interface, rolesRepository: RolesRepository.Interface, teamsRepository: TeamsRepository.Interface);
     getPermissions(identity: Identity): Promise<{
-        _src: string;
         name: string;
+        _src: string;
     }[] | null>;
 }
 export declare const GetPermissionsFromIdentity: typeof GetPermissionsFromGroupsAndTeamsImpl & {

package/features/security/utils/getPermissionsFromRoles.d.ts

@@ -3,6 +3,6 @@ export declare const getPermissionsFromRoles: (securityGroups: Array<{
     permissions: SecurityPermission[];
     id: string;
 }>) => {
-    _src: string;
     name: string;
+    _src: string;
 }[];

package/features/serviceDiscovery/ServiceDiscovery.d.ts

@@ -0,0 +1,17 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IServiceManifest {
+    name: string;
+    manifest: GenericRecord<string>;
+}
+export interface IServiceManifestLoader {
+    load(): Promise<IServiceManifest[] | undefined>;
+}
+type Manifest = GenericRecord<string>;
+export declare class ServiceDiscovery {
+    private static loader;
+    private static manifest;
+    static setLoader(loader: IServiceManifestLoader): void;
+    static load(): Promise<Manifest | undefined>;
+    static clear(): void;
+}
+export {};

package/features/serviceDiscovery/ServiceDiscovery.js

@@ -0,0 +1,22 @@
+class ServiceDiscovery {
+    static setLoader(loader) {
+        this.loader = loader;
+    }
+    static async load() {
+        if (this.manifest) return this.manifest;
+        if (!this.loader) throw new Error("ServiceDiscovery loader not configured. Call ServiceDiscovery.setLoader() before loading manifests.");
+        const manifests = await this.loader.load();
+        if (!manifests) return;
+        this.manifest = manifests.reduce((acc, item)=>({
+                ...acc,
+                [item.name]: item.manifest
+            }), {});
+        return this.manifest;
+    }
+    static clear() {
+        this.manifest = void 0;
+    }
+}
+export { ServiceDiscovery };
+
+//# sourceMappingURL=ServiceDiscovery.js.map

package/features/serviceDiscovery/ServiceDiscovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/serviceDiscovery/ServiceDiscovery.js","sources":["../../../src/features/serviceDiscovery/ServiceDiscovery.ts"],"sourcesContent":["import type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IServiceManifest {\n    name: string;\n    manifest: GenericRecord<string>;\n}\n\nexport interface IServiceManifestLoader {\n    load(): Promise<IServiceManifest[] | undefined>;\n}\n\ntype Manifest = GenericRecord<string>;\n\nexport class ServiceDiscovery {\n    private static loader: IServiceManifestLoader | undefined;\n    private static manifest: Manifest | undefined;\n\n    static setLoader(loader: IServiceManifestLoader): void {\n        this.loader = loader;\n    }\n\n    static async load(): Promise<Manifest | undefined> {\n        if (this.manifest) {\n            return this.manifest;\n        }\n\n        if (!this.loader) {\n            throw new Error(\n                \"ServiceDiscovery loader not configured. Call ServiceDiscovery.setLoader() before loading manifests.\"\n            );\n        }\n\n        const manifests = await this.loader.load();\n\n        if (!manifests) {\n            return undefined;\n        }\n\n        this.manifest = manifests.reduce<Manifest>((acc, item) => {\n            return { ...acc, [item.name]: item.manifest };\n        }, {});\n\n        return this.manifest;\n    }\n\n    static clear(): void {\n        this.manifest = undefined;\n    }\n}\n"],"names":["ServiceDiscovery","loader","Error","manifests","acc","item","undefined"],"mappings":"AAaO,MAAMA;IAIT,OAAO,UAAUC,MAA8B,EAAQ;QACnD,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,aAAa,OAAsC;QAC/C,IAAI,IAAI,CAAC,QAAQ,EACb,OAAO,IAAI,CAAC,QAAQ;QAGxB,IAAI,CAAC,IAAI,CAAC,MAAM,EACZ,MAAM,IAAIC,MACN;QAIR,MAAMC,YAAY,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI;QAExC,IAAI,CAACA,WACD;QAGJ,IAAI,CAAC,QAAQ,GAAGA,UAAU,MAAM,CAAW,CAACC,KAAKC,OACtC;gBAAE,GAAGD,GAAG;gBAAE,CAACC,KAAK,IAAI,CAAC,EAAEA,KAAK,QAAQ;YAAC,IAC7C,CAAC;QAEJ,OAAO,IAAI,CAAC,QAAQ;IACxB;IAEA,OAAO,QAAc;QACjB,IAAI,CAAC,QAAQ,GAAGC;IACpB;AACJ"}

package/features/serviceDiscovery/__tests__/ServiceDiscovery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/features/serviceDiscovery/__tests__/ServiceDiscovery.test.js

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { ServiceDiscovery } from "../ServiceDiscovery.js";
+describe("ServiceDiscovery", ()=>{
+    beforeEach(()=>{
+        ServiceDiscovery.clear();
+    });
+    it("should throw if no loader is set", async ()=>{
+        ServiceDiscovery.loader = void 0;
+        await expect(ServiceDiscovery.load()).rejects.toThrow("ServiceDiscovery loader not configured");
+    });
+    it("should load manifests and combine them by name", async ()=>{
+        const loader = {
+            async load () {
+                return [
+                    {
+                        name: "api",
+                        manifest: {
+                            cloudfront: {
+                                distributionId: "123"
+                            }
+                        }
+                    },
+                    {
+                        name: "core",
+                        manifest: {
+                            bucket: {
+                                name: "my-bucket"
+                            }
+                        }
+                    }
+                ];
+            }
+        };
+        ServiceDiscovery.setLoader(loader);
+        const result = await ServiceDiscovery.load();
+        expect(result).toEqual({
+            api: {
+                cloudfront: {
+                    distributionId: "123"
+                }
+            },
+            core: {
+                bucket: {
+                    name: "my-bucket"
+                }
+            }
+        });
+    });
+    it("should cache the result and not call loader again", async ()=>{
+        let callCount = 0;
+        const loader = {
+            async load () {
+                callCount++;
+                return [
+                    {
+                        name: "api",
+                        manifest: {
+                            url: "https://example.com"
+                        }
+                    }
+                ];
+            }
+        };
+        ServiceDiscovery.setLoader(loader);
+        await ServiceDiscovery.load();
+        await ServiceDiscovery.load();
+        await ServiceDiscovery.load();
+        expect(callCount).toBe(1);
+    });
+    it("should return undefined when loader returns undefined", async ()=>{
+        const loader = {
+            async load () {}
+        };
+        ServiceDiscovery.setLoader(loader);
+        const result = await ServiceDiscovery.load();
+        expect(result).toBeUndefined();
+    });
+    it("should reload after clear()", async ()=>{
+        let callCount = 0;
+        const loader = {
+            async load () {
+                callCount++;
+                return [
+                    {
+                        name: "api",
+                        manifest: {
+                            version: callCount
+                        }
+                    }
+                ];
+            }
+        };
+        ServiceDiscovery.setLoader(loader);
+        const first = await ServiceDiscovery.load();
+        expect(first).toEqual({
+            api: {
+                version: 1
+            }
+        });
+        ServiceDiscovery.clear();
+        const second = await ServiceDiscovery.load();
+        expect(second).toEqual({
+            api: {
+                version: 2
+            }
+        });
+        expect(callCount).toBe(2);
+    });
+});
+
+//# sourceMappingURL=ServiceDiscovery.test.js.map

package/features/serviceDiscovery/__tests__/ServiceDiscovery.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/serviceDiscovery/__tests__/ServiceDiscovery.test.js","sources":["../../../../src/features/serviceDiscovery/__tests__/ServiceDiscovery.test.ts"],"sourcesContent":["import { describe, it, expect, beforeEach } from \"vitest\";\nimport { ServiceDiscovery } from \"../ServiceDiscovery.js\";\nimport type { IServiceManifestLoader } from \"../ServiceDiscovery.js\";\n\ndescribe(\"ServiceDiscovery\", () => {\n    beforeEach(() => {\n        ServiceDiscovery.clear();\n    });\n\n    it(\"should throw if no loader is set\", async () => {\n        (ServiceDiscovery as any).loader = undefined;\n\n        await expect(ServiceDiscovery.load()).rejects.toThrow(\n            \"ServiceDiscovery loader not configured\"\n        );\n    });\n\n    it(\"should load manifests and combine them by name\", async () => {\n        const loader: IServiceManifestLoader = {\n            async load() {\n                return [\n                    { name: \"api\", manifest: { cloudfront: { distributionId: \"123\" } } },\n                    { name: \"core\", manifest: { bucket: { name: \"my-bucket\" } } }\n                ];\n            }\n        };\n\n        ServiceDiscovery.setLoader(loader);\n\n        const result = await ServiceDiscovery.load();\n\n        expect(result).toEqual({\n            api: { cloudfront: { distributionId: \"123\" } },\n            core: { bucket: { name: \"my-bucket\" } }\n        });\n    });\n\n    it(\"should cache the result and not call loader again\", async () => {\n        let callCount = 0;\n        const loader: IServiceManifestLoader = {\n            async load() {\n                callCount++;\n                return [{ name: \"api\", manifest: { url: \"https://example.com\" } }];\n            }\n        };\n\n        ServiceDiscovery.setLoader(loader);\n\n        await ServiceDiscovery.load();\n        await ServiceDiscovery.load();\n        await ServiceDiscovery.load();\n\n        expect(callCount).toBe(1);\n    });\n\n    it(\"should return undefined when loader returns undefined\", async () => {\n        const loader: IServiceManifestLoader = {\n            async load() {\n                return undefined;\n            }\n        };\n\n        ServiceDiscovery.setLoader(loader);\n\n        const result = await ServiceDiscovery.load();\n        expect(result).toBeUndefined();\n    });\n\n    it(\"should reload after clear()\", async () => {\n        let callCount = 0;\n        const loader: IServiceManifestLoader = {\n            async load() {\n                callCount++;\n                return [{ name: \"api\", manifest: { version: callCount } }];\n            }\n        };\n\n        ServiceDiscovery.setLoader(loader);\n\n        const first = await ServiceDiscovery.load();\n        expect(first).toEqual({ api: { version: 1 } });\n\n        ServiceDiscovery.clear();\n\n        const second = await ServiceDiscovery.load();\n        expect(second).toEqual({ api: { version: 2 } });\n        expect(callCount).toBe(2);\n    });\n});\n"],"names":["describe","beforeEach","ServiceDiscovery","it","undefined","expect","loader","result","callCount","first","second"],"mappings":";;AAIAA,SAAS,oBAAoB;IACzBC,WAAW;QACPC,iBAAiB,KAAK;IAC1B;IAEAC,GAAG,oCAAoC;QAClCD,iBAAAA,MAA+B,GAAGE;QAEnC,MAAMC,OAAOH,iBAAiB,IAAI,IAAI,OAAO,CAAC,OAAO,CACjD;IAER;IAEAC,GAAG,kDAAkD;QACjD,MAAMG,SAAiC;YACnC,MAAM;gBACF,OAAO;oBACH;wBAAE,MAAM;wBAAO,UAAU;4BAAE,YAAY;gCAAE,gBAAgB;4BAAM;wBAAE;oBAAE;oBACnE;wBAAE,MAAM;wBAAQ,UAAU;4BAAE,QAAQ;gCAAE,MAAM;4BAAY;wBAAE;oBAAE;iBAC/D;YACL;QACJ;QAEAJ,iBAAiB,SAAS,CAACI;QAE3B,MAAMC,SAAS,MAAML,iBAAiB,IAAI;QAE1CG,OAAOE,QAAQ,OAAO,CAAC;YACnB,KAAK;gBAAE,YAAY;oBAAE,gBAAgB;gBAAM;YAAE;YAC7C,MAAM;gBAAE,QAAQ;oBAAE,MAAM;gBAAY;YAAE;QAC1C;IACJ;IAEAJ,GAAG,qDAAqD;QACpD,IAAIK,YAAY;QAChB,MAAMF,SAAiC;YACnC,MAAM;gBACFE;gBACA,OAAO;oBAAC;wBAAE,MAAM;wBAAO,UAAU;4BAAE,KAAK;wBAAsB;oBAAE;iBAAE;YACtE;QACJ;QAEAN,iBAAiB,SAAS,CAACI;QAE3B,MAAMJ,iBAAiB,IAAI;QAC3B,MAAMA,iBAAiB,IAAI;QAC3B,MAAMA,iBAAiB,IAAI;QAE3BG,OAAOG,WAAW,IAAI,CAAC;IAC3B;IAEAL,GAAG,yDAAyD;QACxD,MAAMG,SAAiC;YACnC,MAAM,SAEN;QACJ;QAEAJ,iBAAiB,SAAS,CAACI;QAE3B,MAAMC,SAAS,MAAML,iBAAiB,IAAI;QAC1CG,OAAOE,QAAQ,aAAa;IAChC;IAEAJ,GAAG,+BAA+B;QAC9B,IAAIK,YAAY;QAChB,MAAMF,SAAiC;YACnC,MAAM;gBACFE;gBACA,OAAO;oBAAC;wBAAE,MAAM;wBAAO,UAAU;4BAAE,SAASA;wBAAU;oBAAE;iBAAE;YAC9D;QACJ;QAEAN,iBAAiB,SAAS,CAACI;QAE3B,MAAMG,QAAQ,MAAMP,iBAAiB,IAAI;QACzCG,OAAOI,OAAO,OAAO,CAAC;YAAE,KAAK;gBAAE,SAAS;YAAE;QAAE;QAE5CP,iBAAiB,KAAK;QAEtB,MAAMQ,SAAS,MAAMR,iBAAiB,IAAI;QAC1CG,OAAOK,QAAQ,OAAO,CAAC;YAAE,KAAK;gBAAE,SAAS;YAAE;QAAE;QAC7CL,OAAOG,WAAW,IAAI,CAAC;IAC3B;AACJ"}

package/features/serviceDiscovery/index.d.ts

@@ -0,0 +1,3 @@
+export { ServiceDiscovery } from "./ServiceDiscovery.js";
+export type { IServiceManifestLoader } from "./ServiceDiscovery.js";
+export type { IServiceManifest } from "./ServiceDiscovery.js";

package/features/serviceDiscovery/index.js

@@ -0,0 +1 @@
+export { ServiceDiscovery } from "./ServiceDiscovery.js";

package/features/storageOperations/abstractions.d.ts

@@ -0,0 +1,21 @@
+import type { Container } from "@webiny/di";
+import type { ApiCoreStorageOperations } from "../../types/core.js";
+/**
+ * Builds the api-core storage operations. Resolved + built synchronously inside
+ * ApiCoreFeature.register, so storage is wired the same way for every event — there is no
+ * out-of-feature construction or per-request async initializer. The concrete implementation is
+ * provided by a storage adapter (ApiCoreDdbFeature / ApiCoreSqlFeature) or, in tests, by
+ * registerApiCoreStorageOperations.
+ */
+export interface IApiCoreStorageOperationsFactory {
+    create(): ApiCoreStorageOperations;
+}
+export declare const ApiCoreStorageOperationsFactory: import("@webiny/di").Abstraction<IApiCoreStorageOperationsFactory>;
+export declare namespace ApiCoreStorageOperationsFactory {
+    type Interface = IApiCoreStorageOperationsFactory;
+}
+/**
+ * Register pre-built storage operations as the factory. Used by tests (and anywhere the ops are
+ * already constructed) so ApiCoreFeature.register can resolve them like any adapter-provided factory.
+ */
+export declare const registerApiCoreStorageOperations: (container: Container, storageOperations: ApiCoreStorageOperations) => void;

package/features/storageOperations/abstractions.js

@@ -0,0 +1,10 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ApiCoreStorageOperationsFactory = createAbstraction("ApiCoreStorageOperationsFactory");
+const registerApiCoreStorageOperations = (container, storageOperations)=>{
+    container.registerInstance(ApiCoreStorageOperationsFactory, {
+        create: ()=>storageOperations
+    });
+};
+export { ApiCoreStorageOperationsFactory, registerApiCoreStorageOperations };
+
+//# sourceMappingURL=abstractions.js.map

package/features/storageOperations/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storageOperations/abstractions.js","sources":["../../../src/features/storageOperations/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport type { ApiCoreStorageOperations } from \"~/types/core.js\";\n\n/**\n * Builds the api-core storage operations. Resolved + built synchronously inside\n * ApiCoreFeature.register, so storage is wired the same way for every event — there is no\n * out-of-feature construction or per-request async initializer. The concrete implementation is\n * provided by a storage adapter (ApiCoreDdbFeature / ApiCoreSqlFeature) or, in tests, by\n * registerApiCoreStorageOperations.\n */\nexport interface IApiCoreStorageOperationsFactory {\n    create(): ApiCoreStorageOperations;\n}\n\nexport const ApiCoreStorageOperationsFactory = createAbstraction<IApiCoreStorageOperationsFactory>(\n    \"ApiCoreStorageOperationsFactory\"\n);\n\nexport namespace ApiCoreStorageOperationsFactory {\n    export type Interface = IApiCoreStorageOperationsFactory;\n}\n\n/**\n * Register pre-built storage operations as the factory. Used by tests (and anywhere the ops are\n * already constructed) so ApiCoreFeature.register can resolve them like any adapter-provided factory.\n */\nexport const registerApiCoreStorageOperations = (\n    container: Container,\n    storageOperations: ApiCoreStorageOperations\n): void => {\n    container.registerInstance(ApiCoreStorageOperationsFactory, {\n        create: () => storageOperations\n    });\n};\n"],"names":["ApiCoreStorageOperationsFactory","createAbstraction","registerApiCoreStorageOperations","container","storageOperations"],"mappings":";AAeO,MAAMA,kCAAkCC,kBAC3C;AAWG,MAAMC,mCAAmC,CAC5CC,WACAC;IAEAD,UAAU,gBAAgB,CAACH,iCAAiC;QACxD,QAAQ,IAAMI;IAClB;AACJ"}

package/features/tenancy/CreateTenant/CreateTenantUseCase.d.ts

@@ -8,7 +8,7 @@ declare class CreateTenantUseCaseImpl implements UseCaseAbstraction.Interface {
     private eventPublisher;
     private repository;
     constructor(eventPublisher: EventPublisher.Interface, repository: CreateTenantRepository.Interface);
-    execute(data: CreateTenantInput): Promise<Result<Tenant, never> | Result<never, CreateTenantError>>;
+    execute(data: CreateTenantInput): Promise<Result<never, CreateTenantError> | Result<Tenant, never>>;
 }
 export declare const CreateTenantUseCase: import("@webiny/di").Implementation<typeof CreateTenantUseCaseImpl>;
 export {};

package/features/tenancy/InstallTenant/InstallTenantUseCase.d.ts

@@ -13,7 +13,7 @@ declare class InstallTenantUseCaseImpl implements UseCaseAbstraction.Interface {
     private updateTenantUseCase;
     private resolver;
     constructor(tenantContext: TenantContext.Interface, eventPublisher: EventPublisher.Interface, appInstallers: AppInstaller.Interface[], updateTenantUseCase: UpdateTenantUseCase.Interface);
-    execute({ tenant, installationInput }: TenantInstallationInput): Promise<Result<void, never> | Result<never, InstallationDependencyError> | Result<never, InstallTenantError>>;
+    execute({ tenant, installationInput }: TenantInstallationInput): Promise<Result<void, never> | Result<never, InstallTenantError> | Result<never, InstallationDependencyError>>;
     private rollback;
 }
 export declare const InstallTenantUseCase: import("@webiny/di").Implementation<typeof InstallTenantUseCaseImpl>;

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.d.ts

@@ -9,9 +9,9 @@ declare class UpdateTenantUseCaseImpl implements UseCaseAbstraction.Interface {
     private eventPublisher;
     private repository;
     constructor(getTenantById: GetTenantByIdUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: UpdateTenantRepository.Interface);
-    execute(id: string, data: Partial<Tenant>): Promise<({
+    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, never> | ({
         _error: import("../GetTenantById/abstractions.js").GetTenantByIdError;
-    } & Result<Tenant, import("../GetTenantById/abstractions.js").GetTenantByIdError>) | Result<Tenant, never>>;
+    } & Result<Tenant, import("../GetTenantById/abstractions.js").GetTenantByIdError>)>;
 }
 export declare const UpdateTenantUseCase: import("@webiny/di").Implementation<typeof UpdateTenantUseCaseImpl>;
 export {};

package/features/users/CreateUser/decorators/CreateUserWithWcpIncrement.d.ts

@@ -5,7 +5,7 @@ declare class CreateUserWithWcpIncrementImpl implements CreateUserUseCase.Interf
     private wcp;
     private decoratee;
     constructor(wcp: WcpContext.Interface, decoratee: CreateUserUseCase.Interface);
-    execute(input: CreateUserInput): Promise<import("@webiny/feature/api").Result<import("~/features/users/shared/types.js").AdminUser, import("../../shared/errors.js").UserStorageError | import("../../shared/errors.js").UserNotFoundError | import("../../shared/errors.js").EmailTakenError | import("../../shared/errors.js").UserValidationError | import("../../shared/errors.js").NotAuthorizedError>>;
+    execute(input: CreateUserInput): Promise<import("@webiny/feature/api").Result<import("~/features/users/shared/types.js").AdminUser, import("../../shared/errors.js").EmailTakenError | import("../../shared/errors.js").NotAuthorizedError | import("../../shared/errors.js").UserNotFoundError | import("../../shared/errors.js").UserStorageError | import("../../shared/errors.js").UserValidationError>>;
 }
 export declare const CreateUserWithWcpIncrement: typeof CreateUserWithWcpIncrementImpl;
 export {};