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

package/ApiCoreFeature.d.ts

@@ -1,6 +1,6 @@
 import { Container } from "@webiny/di";
-import type { ApiCoreStorageOperations } from "./types/core.js";
+import type { ApiCoreConfig } from "./types/core.js";
 export declare const ApiCoreFeature: {
     name: string;
-    register(container: Container, context: ApiCoreStorageOperations): void;
+    register(container: Container, context?: ApiCoreConfig | undefined): void;
 };

package/ApiCoreFeature.js

@@ -5,33 +5,51 @@ import { SecurityFeature } from "./features/security/SecurityFeature.js";
 import { SystemFeature } from "./features/system/SystemFeature.js";
 import { TenancyFeature } from "./features/tenancy/TenancyFeature.js";
 import { AdminUsersFeature } from "./features/users/AdminUsersFeature.js";
+import { ApiCoreStorageOperationsFactory } from "./features/storageOperations/abstractions.js";
 import { IdpAuthenticatorFeature } from "./idp/feature.js";
 import { KeyValueStoreFeature } from "./features/keyValueStore/feature.js";
 import { BuildParamsFeature } from "./features/buildParams/feature.js";
 import { EncryptionFeature } from "./features/encryption/feature.js";
+import { HasherFeature } from "./features/hashing/feature.js";
 import { FeatureFlagsFeature } from "./features/featureFlags/feature.js";
 import { MaskerFeature } from "./features/masker/feature.js";
 import { AiFeature } from "./features/ai/feature.js";
+import { WcpFeature } from "./features/wcp/WcpFeature.js";
 import { NullWebhookDispatcher } from "./features/webhooks/WebhookDispatcher/NullWebhookDispatcher.js";
 import { WebhookProviderFeature } from "./features/webhooks/index.js";
+import { RequestContextFeature } from "./features/requestContext/index.js";
+import { ApiCoreSchemaFactory } from "./graphql/ApiCoreSchemaFactory.js";
+import { SecuritySchemaFactory } from "./graphql/security/SecuritySchemaFactory.js";
+import { UsersSchemaFactory } from "./graphql/users/UsersSchemaFactory.js";
+import { SystemSchemaFactory } from "./graphql/system/SystemSchemaFactory.js";
+import { WcpSchemaFactory } from "./graphql/wcp/WcpSchemaFactory.js";
 const ApiCoreFeature = createFeature({
     name: "ApiCore",
-    register (container, config) {
+    register (container, config = {}) {
+        const storageOperations = container.resolve(ApiCoreStorageOperationsFactory).create();
+        WcpFeature.register(container, config.wcpLicense);
         MaskerFeature.register(container);
         AiFeature.register(container);
         LoggerFeature.register(container);
         EventPublisherFeature.register(container);
         BuildParamsFeature.register(container);
         EncryptionFeature.register(container);
+        HasherFeature.register(container);
         FeatureFlagsFeature.register(container);
-        TenancyFeature.register(container, config.tenancyStorageOperations);
-        SecurityFeature.register(container, config.securityStorageOperations);
-        AdminUsersFeature.register(container, config.usersStorageOperations);
-        KeyValueStoreFeature.register(container, config.keyValueStorageOperations);
+        TenancyFeature.register(container, storageOperations.tenancyStorageOperations);
+        SecurityFeature.register(container, storageOperations.securityStorageOperations);
+        AdminUsersFeature.register(container, storageOperations.usersStorageOperations);
+        KeyValueStoreFeature.register(container, storageOperations.keyValueStorageOperations);
         SystemFeature.register(container);
         IdpAuthenticatorFeature.register(container);
+        RequestContextFeature.register(container);
         container.register(NullWebhookDispatcher).inSingletonScope();
         WebhookProviderFeature.register(container);
+        container.register(ApiCoreSchemaFactory);
+        container.register(SecuritySchemaFactory);
+        container.register(UsersSchemaFactory);
+        container.register(SystemSchemaFactory);
+        container.register(WcpSchemaFactory);
     }
 });
 export { ApiCoreFeature };

package/ApiCoreFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"ApiCoreFeature.js","sources":["../src/ApiCoreFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { EventPublisherFeature } from \"~/features/eventPublisher/feature.js\";\nimport { LoggerFeature } from \"~/features/logger/feature.js\";\nimport { SecurityFeature } from \"~/features/security/SecurityFeature.js\";\nimport { SystemFeature } from \"~/features/system/SystemFeature.js\";\nimport { TenancyFeature } from \"./features/tenancy/TenancyFeature.js\";\nimport { AdminUsersFeature } from \"~/features/users/AdminUsersFeature.js\";\nimport type { ApiCoreStorageOperations } from \"~/types/core.js\";\nimport { IdpAuthenticatorFeature } from \"~/idp/feature.js\";\nimport { KeyValueStoreFeature } from \"~/features/keyValueStore/feature.js\";\nimport { BuildParamsFeature } from \"~/features/buildParams/feature.js\";\nimport { EncryptionFeature } from \"~/features/encryption/feature.js\";\nimport { FeatureFlagsFeature } from \"~/features/featureFlags/feature.js\";\nimport { MaskerFeature } from \"~/features/masker/feature.js\";\nimport { AiFeature } from \"~/features/ai/feature.js\";\nimport { NullWebhookDispatcher } from \"./features/webhooks/WebhookDispatcher/NullWebhookDispatcher.js\";\nimport { WebhookProviderFeature } from \"~/features/webhooks/index.js\";\n\nexport const ApiCoreFeature = createFeature({\n    name: \"ApiCore\",\n    register(container: Container, config: ApiCoreStorageOperations) {\n        // Register features\n        MaskerFeature.register(container);\n        AiFeature.register(container);\n        LoggerFeature.register(container);\n        EventPublisherFeature.register(container);\n        BuildParamsFeature.register(container);\n        EncryptionFeature.register(container);\n        FeatureFlagsFeature.register(container);\n        TenancyFeature.register(container, config.tenancyStorageOperations);\n        SecurityFeature.register(container, config.securityStorageOperations);\n        AdminUsersFeature.register(container, config.usersStorageOperations);\n        KeyValueStoreFeature.register(container, config.keyValueStorageOperations);\n        SystemFeature.register(container);\n        IdpAuthenticatorFeature.register(container);\n        container.register(NullWebhookDispatcher).inSingletonScope();\n        WebhookProviderFeature.register(container);\n    }\n});\n"],"names":["ApiCoreFeature","createFeature","container","config","MaskerFeature","AiFeature","LoggerFeature","EventPublisherFeature","BuildParamsFeature","EncryptionFeature","FeatureFlagsFeature","TenancyFeature","SecurityFeature","AdminUsersFeature","KeyValueStoreFeature","SystemFeature","IdpAuthenticatorFeature","NullWebhookDispatcher","WebhookProviderFeature"],"mappings":";;;;;;;;;;;;;;;;AAmBO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAoB,EAAEC,MAAgC;QAE3DC,cAAc,QAAQ,CAACF;QACvBG,UAAU,QAAQ,CAACH;QACnBI,cAAc,QAAQ,CAACJ;QACvBK,sBAAsB,QAAQ,CAACL;QAC/BM,mBAAmB,QAAQ,CAACN;QAC5BO,kBAAkB,QAAQ,CAACP;QAC3BQ,oBAAoB,QAAQ,CAACR;QAC7BS,eAAe,QAAQ,CAACT,WAAWC,OAAO,wBAAwB;QAClES,gBAAgB,QAAQ,CAACV,WAAWC,OAAO,yBAAyB;QACpEU,kBAAkB,QAAQ,CAACX,WAAWC,OAAO,sBAAsB;QACnEW,qBAAqB,QAAQ,CAACZ,WAAWC,OAAO,yBAAyB;QACzEY,cAAc,QAAQ,CAACb;QACvBc,wBAAwB,QAAQ,CAACd;QACjCA,UAAU,QAAQ,CAACe,uBAAuB,gBAAgB;QAC1DC,uBAAuB,QAAQ,CAAChB;IACpC;AACJ"}
+{"version":3,"file":"ApiCoreFeature.js","sources":["../src/ApiCoreFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { EventPublisherFeature } from \"~/features/eventPublisher/feature.js\";\nimport { LoggerFeature } from \"~/features/logger/feature.js\";\nimport { SecurityFeature } from \"~/features/security/SecurityFeature.js\";\nimport { SystemFeature } from \"~/features/system/SystemFeature.js\";\nimport { TenancyFeature } from \"./features/tenancy/TenancyFeature.js\";\nimport { AdminUsersFeature } from \"~/features/users/AdminUsersFeature.js\";\nimport type { ApiCoreConfig } from \"~/types/core.js\";\nimport { ApiCoreStorageOperationsFactory } from \"~/features/storageOperations/abstractions.js\";\nimport { IdpAuthenticatorFeature } from \"~/idp/feature.js\";\nimport { KeyValueStoreFeature } from \"~/features/keyValueStore/feature.js\";\nimport { BuildParamsFeature } from \"~/features/buildParams/feature.js\";\nimport { EncryptionFeature } from \"~/features/encryption/feature.js\";\nimport { HasherFeature } from \"~/features/hashing/feature.js\";\nimport { FeatureFlagsFeature } from \"~/features/featureFlags/feature.js\";\nimport { MaskerFeature } from \"~/features/masker/feature.js\";\nimport { AiFeature } from \"~/features/ai/feature.js\";\nimport { WcpFeature } from \"~/features/wcp/WcpFeature.js\";\nimport { NullWebhookDispatcher } from \"./features/webhooks/WebhookDispatcher/NullWebhookDispatcher.js\";\nimport { WebhookProviderFeature } from \"~/features/webhooks/index.js\";\nimport { RequestContextFeature } from \"~/features/requestContext/index.js\";\nimport { ApiCoreSchemaFactory } from \"~/graphql/ApiCoreSchemaFactory.js\";\nimport { SecuritySchemaFactory } from \"~/graphql/security/SecuritySchemaFactory.js\";\nimport { UsersSchemaFactory } from \"~/graphql/users/UsersSchemaFactory.js\";\nimport { SystemSchemaFactory } from \"~/graphql/system/SystemSchemaFactory.js\";\nimport { WcpSchemaFactory } from \"~/graphql/wcp/WcpSchemaFactory.js\";\n\nexport const ApiCoreFeature = createFeature({\n    name: \"ApiCore\",\n    register(container: Container, config: ApiCoreConfig = {}) {\n        // Storage operations are built synchronously, here, from the adapter-provided factory —\n        // the same way for every event (no out-of-feature construction, no async initializer).\n        const storageOperations = container.resolve(ApiCoreStorageOperationsFactory).create();\n\n        // Register features\n        WcpFeature.register(container, config.wcpLicense);\n        MaskerFeature.register(container);\n        AiFeature.register(container);\n        LoggerFeature.register(container);\n        EventPublisherFeature.register(container);\n        BuildParamsFeature.register(container);\n        EncryptionFeature.register(container);\n        HasherFeature.register(container);\n        FeatureFlagsFeature.register(container);\n        TenancyFeature.register(container, storageOperations.tenancyStorageOperations);\n        SecurityFeature.register(container, storageOperations.securityStorageOperations);\n        AdminUsersFeature.register(container, storageOperations.usersStorageOperations);\n        KeyValueStoreFeature.register(container, storageOperations.keyValueStorageOperations);\n        SystemFeature.register(container);\n        IdpAuthenticatorFeature.register(container);\n        RequestContextFeature.register(container);\n        container.register(NullWebhookDispatcher).inSingletonScope();\n        WebhookProviderFeature.register(container);\n\n        // Core API GraphQL schema: a base factory (root types + scalars) plus one\n        // CoreGraphQLSchemaFactory per domain.\n        container.register(ApiCoreSchemaFactory);\n        container.register(SecuritySchemaFactory);\n        container.register(UsersSchemaFactory);\n        container.register(SystemSchemaFactory);\n        container.register(WcpSchemaFactory);\n    }\n});\n"],"names":["ApiCoreFeature","createFeature","container","config","storageOperations","ApiCoreStorageOperationsFactory","WcpFeature","MaskerFeature","AiFeature","LoggerFeature","EventPublisherFeature","BuildParamsFeature","EncryptionFeature","HasherFeature","FeatureFlagsFeature","TenancyFeature","SecurityFeature","AdminUsersFeature","KeyValueStoreFeature","SystemFeature","IdpAuthenticatorFeature","RequestContextFeature","NullWebhookDispatcher","WebhookProviderFeature","ApiCoreSchemaFactory","SecuritySchemaFactory","UsersSchemaFactory","SystemSchemaFactory","WcpSchemaFactory"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4BO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAASC,SAAoB,EAAEC,SAAwB,CAAC,CAAC;QAGrD,MAAMC,oBAAoBF,UAAU,OAAO,CAACG,iCAAiC,MAAM;QAGnFC,WAAW,QAAQ,CAACJ,WAAWC,OAAO,UAAU;QAChDI,cAAc,QAAQ,CAACL;QACvBM,UAAU,QAAQ,CAACN;QACnBO,cAAc,QAAQ,CAACP;QACvBQ,sBAAsB,QAAQ,CAACR;QAC/BS,mBAAmB,QAAQ,CAACT;QAC5BU,kBAAkB,QAAQ,CAACV;QAC3BW,cAAc,QAAQ,CAACX;QACvBY,oBAAoB,QAAQ,CAACZ;QAC7Ba,eAAe,QAAQ,CAACb,WAAWE,kBAAkB,wBAAwB;QAC7EY,gBAAgB,QAAQ,CAACd,WAAWE,kBAAkB,yBAAyB;QAC/Ea,kBAAkB,QAAQ,CAACf,WAAWE,kBAAkB,sBAAsB;QAC9Ec,qBAAqB,QAAQ,CAAChB,WAAWE,kBAAkB,yBAAyB;QACpFe,cAAc,QAAQ,CAACjB;QACvBkB,wBAAwB,QAAQ,CAAClB;QACjCmB,sBAAsB,QAAQ,CAACnB;QAC/BA,UAAU,QAAQ,CAACoB,uBAAuB,gBAAgB;QAC1DC,uBAAuB,QAAQ,CAACrB;QAIhCA,UAAU,QAAQ,CAACsB;QACnBtB,UAAU,QAAQ,CAACuB;QACnBvB,UAAU,QAAQ,CAACwB;QACnBxB,UAAU,QAAQ,CAACyB;QACnBzB,UAAU,QAAQ,CAAC0B;IACvB;AACJ"}

package/exports/api.d.ts

@@ -1,7 +1,8 @@
-export { AiSdk, AiSdkFactory, AiConnectionFactory, Ai } from "../features/ai/index.js";
+export { AiSdk, AiSdkFactory, AiSdkTool, AiConnectionFactory, Ai } from "../features/ai/index.js";
 export type { IAiConnection, IAiConnectionInline } from "../features/ai/index.js";
 export { Logger } from "../features/logger/index.js";
 export { Encryption } from "../features/encryption/index.js";
+export { Hasher } from "../features/hashing/index.js";
 export { BuildParam, BuildParams } from "../features/buildParams/index.js";
 export { DomainEvent, EventPublisher } from "../features/eventPublisher/index.js";
 export { GlobalKeyValueStore, KeyValueStore } from "../features/keyValueStore/index.js";

package/exports/api.js

@@ -1,6 +1,7 @@
-export { Ai, AiConnectionFactory, AiSdk, AiSdkFactory } from "../features/ai/index.js";
+export { Ai, AiConnectionFactory, AiSdk, AiSdkFactory, AiSdkTool } from "../features/ai/index.js";
 export { Logger } from "../features/logger/index.js";
 export { Encryption } from "../features/encryption/index.js";
+export { Hasher } from "../features/hashing/index.js";
 export { BuildParam, BuildParams } from "../features/buildParams/index.js";
 export { DomainEvent, EventPublisher } from "../features/eventPublisher/index.js";
 export { GlobalKeyValueStore, KeyValueStore } from "../features/keyValueStore/index.js";

package/features/ai/feature.js

@@ -3,6 +3,8 @@ import { OpenAiSdkFactory } from "./OpenAiSdkFactory.js";
 import { AnthropicSdkFactory } from "./AnthropicSdkFactory.js";
 import { Ai } from "./Ai.js";
 import { AiSdkTools } from "./AiSdkTools.js";
+import { AiOutputToolRegistry } from "./toolPipeline/AiOutputToolRegistry.js";
+import { AiToolPipelineRunner } from "./toolPipeline/AiToolPipelineRunner.js";
 const AiFeature = createFeature({
     name: "AiFeature",
     register (container) {
@@ -10,6 +12,8 @@ const AiFeature = createFeature({
         container.register(AnthropicSdkFactory);
         container.register(Ai);
         container.register(AiSdkTools);
+        container.register(AiOutputToolRegistry);
+        container.register(AiToolPipelineRunner);
     }
 });
 export { AiFeature };

package/features/ai/feature.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/ai/feature.js","sources":["../../../src/features/ai/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { OpenAiSdkFactory } from \"./OpenAiSdkFactory.js\";\nimport { AnthropicSdkFactory } from \"./AnthropicSdkFactory.js\";\nimport { Ai } from \"./Ai.js\";\nimport { AiSdkTools } from \"./AiSdkTools.js\";\n\nexport const AiFeature = createFeature({\n    name: \"AiFeature\",\n    register(container) {\n        container.register(OpenAiSdkFactory);\n        container.register(AnthropicSdkFactory);\n        container.register(Ai);\n        container.register(AiSdkTools);\n    }\n});\n"],"names":["AiFeature","createFeature","container","OpenAiSdkFactory","AnthropicSdkFactory","Ai","AiSdkTools"],"mappings":";;;;;AAMO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;IACvB;AACJ"}
+{"version":3,"file":"features/ai/feature.js","sources":["../../../src/features/ai/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { OpenAiSdkFactory } from \"./OpenAiSdkFactory.js\";\nimport { AnthropicSdkFactory } from \"./AnthropicSdkFactory.js\";\nimport { Ai } from \"./Ai.js\";\nimport { AiSdkTools } from \"./AiSdkTools.js\";\nimport { AiOutputToolRegistry } from \"./toolPipeline/AiOutputToolRegistry.js\";\nimport { AiToolPipelineRunner } from \"./toolPipeline/AiToolPipelineRunner.js\";\n\nexport const AiFeature = createFeature({\n    name: \"AiFeature\",\n    register(container) {\n        container.register(OpenAiSdkFactory);\n        container.register(AnthropicSdkFactory);\n        container.register(Ai);\n        container.register(AiSdkTools);\n        container.register(AiOutputToolRegistry);\n        container.register(AiToolPipelineRunner);\n    }\n});\n"],"names":["AiFeature","createFeature","container","OpenAiSdkFactory","AnthropicSdkFactory","Ai","AiSdkTools","AiOutputToolRegistry","AiToolPipelineRunner"],"mappings":";;;;;;;AAQO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;IACvB;AACJ"}

package/features/ai/index.d.ts

@@ -1,3 +1,5 @@
 export { AiSdk, AiSdkFactory, AiConnectionFactory, Ai, AiSdkTool, AiSdkTools } from "./abstractions.js";
 export type { IAiConnection, IAiConnectionInline, AiModel, IAiSdkModel, IAiSdkTool, IAiSdkTools } from "./abstractions.js";
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./toolPipeline/index.js";
+export type { IAiOutputTool, IAiOutputToolRegistry, IAiToolPipelineRunner } from "./toolPipeline/index.js";
 export { AiFeature } from "./feature.js";

package/features/ai/index.js

@@ -1,2 +1,3 @@
 export { Ai, AiConnectionFactory, AiSdk, AiSdkFactory, AiSdkTool, AiSdkTools } from "./abstractions.js";
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./toolPipeline/index.js";
 export { AiFeature } from "./feature.js";

package/features/ai/toolPipeline/AiOutputToolRegistry.d.ts

@@ -0,0 +1,11 @@
+import { type IAiOutputTool, type IAiOutputToolRegistry } from "./abstractions.js";
+declare class AiOutputToolRegistryImpl implements IAiOutputToolRegistry {
+    private toolMap;
+    constructor(tools: IAiOutputTool[]);
+    has(name: string): boolean;
+    invoke(name: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export declare const AiOutputToolRegistry: typeof AiOutputToolRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiOutputToolRegistry>;
+};
+export {};

package/features/ai/toolPipeline/AiOutputToolRegistry.js

@@ -0,0 +1,31 @@
+import { AiOutputTool, AiOutputToolRegistry } from "./abstractions.js";
+class AiOutputToolRegistryImpl {
+    constructor(tools){
+        this.toolMap = new Map(tools.map((t)=>[
+                t.name,
+                t
+            ]));
+    }
+    has(name) {
+        return this.toolMap.has(name);
+    }
+    async invoke(name, params) {
+        const tool = this.toolMap.get(name);
+        if (!tool) return;
+        return tool.execute(params);
+    }
+}
+const AiOutputToolRegistry_AiOutputToolRegistry = AiOutputToolRegistry.createImplementation({
+    implementation: AiOutputToolRegistryImpl,
+    dependencies: [
+        [
+            AiOutputTool,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { AiOutputToolRegistry_AiOutputToolRegistry as AiOutputToolRegistry };
+
+//# sourceMappingURL=AiOutputToolRegistry.js.map

package/features/ai/toolPipeline/AiOutputToolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/toolPipeline/AiOutputToolRegistry.js","sources":["../../../../src/features/ai/toolPipeline/AiOutputToolRegistry.ts"],"sourcesContent":["import {\n    AiOutputTool,\n    AiOutputToolRegistry as Abstraction,\n    type IAiOutputTool,\n    type IAiOutputToolRegistry\n} from \"./abstractions.js\";\n\nclass AiOutputToolRegistryImpl implements IAiOutputToolRegistry {\n    private toolMap: Map<string, IAiOutputTool>;\n\n    constructor(tools: IAiOutputTool[]) {\n        this.toolMap = new Map(tools.map(t => [t.name, t]));\n    }\n\n    has(name: string): boolean {\n        return this.toolMap.has(name);\n    }\n\n    async invoke(name: string, params: Record<string, unknown>): Promise<unknown> {\n        const tool = this.toolMap.get(name);\n        if (!tool) {\n            return undefined;\n        }\n        return tool.execute(params);\n    }\n}\n\nexport const AiOutputToolRegistry = Abstraction.createImplementation({\n    implementation: AiOutputToolRegistryImpl,\n    dependencies: [[AiOutputTool, { multiple: true }]]\n});\n"],"names":["AiOutputToolRegistryImpl","tools","Map","t","name","params","tool","AiOutputToolRegistry","Abstraction","AiOutputTool"],"mappings":";AAOA,MAAMA;IAGF,YAAYC,KAAsB,CAAE;QAChC,IAAI,CAAC,OAAO,GAAG,IAAIC,IAAID,MAAM,GAAG,CAACE,CAAAA,IAAK;gBAACA,EAAE,IAAI;gBAAEA;aAAE;IACrD;IAEA,IAAIC,IAAY,EAAW;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA;IAC5B;IAEA,MAAM,OAAOA,IAAY,EAAEC,MAA+B,EAAoB;QAC1E,MAAMC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACF;QAC9B,IAAI,CAACE,MACD;QAEJ,OAAOA,KAAK,OAAO,CAACD;IACxB;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBR;IAChB,cAAc;QAAC;YAACS;YAAc;gBAAE,UAAU;YAAK;SAAE;KAAC;AACtD"}

package/features/ai/toolPipeline/AiToolPipelineRunner.d.ts

@@ -0,0 +1,10 @@
+import { type IAiOutputToolRegistry, type IAiToolPipelineRunner } from "./abstractions.js";
+declare class AiToolPipelineRunnerImpl implements IAiToolPipelineRunner {
+    private registry;
+    constructor(registry: IAiOutputToolRegistry);
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const AiToolPipelineRunner: typeof AiToolPipelineRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiToolPipelineRunner>;
+};
+export {};

package/features/ai/toolPipeline/AiToolPipelineRunner.js

@@ -0,0 +1,36 @@
+import { AiOutputToolRegistry, AiToolPipelineRunner } from "./abstractions.js";
+function isToolEnvelope(value) {
+    return "object" == typeof value && null !== value && "tool" in value && "string" == typeof value.tool && "params" in value && "object" == typeof value.params;
+}
+class AiToolPipelineRunnerImpl {
+    constructor(registry){
+        this.registry = registry;
+    }
+    async resolve(data) {
+        if (null == data) return data;
+        if (isToolEnvelope(data)) {
+            if (!this.registry.has(data.tool)) return data;
+            const result = await this.registry.invoke(data.tool, data.params);
+            return this.resolve(result);
+        }
+        if (Array.isArray(data)) return Promise.all(data.map((item)=>this.resolve(item)));
+        if ("object" == typeof data) {
+            const entries = Object.entries(data);
+            const resolvedValues = await Promise.all(entries.map(([, value])=>this.resolve(value)));
+            return Object.fromEntries(entries.map(([key], i)=>[
+                    key,
+                    resolvedValues[i]
+                ]));
+        }
+        return data;
+    }
+}
+const AiToolPipelineRunner_AiToolPipelineRunner = AiToolPipelineRunner.createImplementation({
+    implementation: AiToolPipelineRunnerImpl,
+    dependencies: [
+        AiOutputToolRegistry
+    ]
+});
+export { AiToolPipelineRunner_AiToolPipelineRunner as AiToolPipelineRunner };
+
+//# sourceMappingURL=AiToolPipelineRunner.js.map

package/features/ai/toolPipeline/AiToolPipelineRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/toolPipeline/AiToolPipelineRunner.js","sources":["../../../../src/features/ai/toolPipeline/AiToolPipelineRunner.ts"],"sourcesContent":["import {\n    AiOutputToolRegistry,\n    AiToolPipelineRunner as Abstraction,\n    type IAiOutputToolRegistry,\n    type IAiToolPipelineRunner\n} from \"./abstractions.js\";\n\nfunction isToolEnvelope(\n    value: unknown\n): value is { tool: string; params: Record<string, unknown> } {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        \"tool\" in value &&\n        typeof (value as Record<string, unknown>).tool === \"string\" &&\n        \"params\" in value &&\n        typeof (value as Record<string, unknown>).params === \"object\"\n    );\n}\n\nclass AiToolPipelineRunnerImpl implements IAiToolPipelineRunner {\n    constructor(private registry: IAiOutputToolRegistry) {}\n\n    async resolve(data: unknown): Promise<unknown> {\n        if (data === null || data === undefined) {\n            return data;\n        }\n\n        if (isToolEnvelope(data)) {\n            if (!this.registry.has(data.tool)) {\n                return data;\n            }\n            const result = await this.registry.invoke(data.tool, data.params);\n            return this.resolve(result);\n        }\n\n        if (Array.isArray(data)) {\n            return Promise.all(data.map(item => this.resolve(item)));\n        }\n\n        if (typeof data === \"object\") {\n            const entries = Object.entries(data as Record<string, unknown>);\n            const resolvedValues = await Promise.all(\n                entries.map(([, value]) => this.resolve(value))\n            );\n            return Object.fromEntries(entries.map(([key], i) => [key, resolvedValues[i]]));\n        }\n\n        return data;\n    }\n}\n\nexport const AiToolPipelineRunner = Abstraction.createImplementation({\n    implementation: AiToolPipelineRunnerImpl,\n    dependencies: [AiOutputToolRegistry]\n});\n"],"names":["isToolEnvelope","value","AiToolPipelineRunnerImpl","registry","data","result","Array","Promise","item","entries","Object","resolvedValues","key","i","AiToolPipelineRunner","Abstraction","AiOutputToolRegistry"],"mappings":";AAOA,SAASA,eACLC,KAAc;IAEd,OACI,AAAiB,YAAjB,OAAOA,SACPA,AAAU,SAAVA,SACA,UAAUA,SACV,AAAmD,YAAnD,OAAQA,MAAkC,IAAI,IAC9C,YAAYA,SACZ,AAAqD,YAArD,OAAQA,MAAkC,MAAM;AAExD;AAEA,MAAMC;IACF,YAAoBC,QAA+B,CAAE;aAAjCA,QAAQ,GAARA;IAAkC;IAEtD,MAAM,QAAQC,IAAa,EAAoB;QAC3C,IAAIA,QAAAA,MACA,OAAOA;QAGX,IAAIJ,eAAeI,OAAO;YACtB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAACA,KAAK,IAAI,GAC5B,OAAOA;YAEX,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAACD,KAAK,IAAI,EAAEA,KAAK,MAAM;YAChE,OAAO,IAAI,CAAC,OAAO,CAACC;QACxB;QAEA,IAAIC,MAAM,OAAO,CAACF,OACd,OAAOG,QAAQ,GAAG,CAACH,KAAK,GAAG,CAACI,CAAAA,OAAQ,IAAI,CAAC,OAAO,CAACA;QAGrD,IAAI,AAAgB,YAAhB,OAAOJ,MAAmB;YAC1B,MAAMK,UAAUC,OAAO,OAAO,CAACN;YAC/B,MAAMO,iBAAiB,MAAMJ,QAAQ,GAAG,CACpCE,QAAQ,GAAG,CAAC,CAAC,GAAGR,MAAM,GAAK,IAAI,CAAC,OAAO,CAACA;YAE5C,OAAOS,OAAO,WAAW,CAACD,QAAQ,GAAG,CAAC,CAAC,CAACG,IAAI,EAAEC,IAAM;oBAACD;oBAAKD,cAAc,CAACE,EAAE;iBAAC;QAChF;QAEA,OAAOT;IACX;AACJ;AAEO,MAAMU,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBb;IAChB,cAAc;QAACc;KAAqB;AACxC"}

package/features/ai/toolPipeline/abstractions.d.ts

@@ -0,0 +1,23 @@
+export interface IAiOutputTool {
+    readonly name: string;
+    execute(params: Record<string, unknown>): Promise<unknown>;
+}
+export declare const AiOutputTool: import("@webiny/di").Abstraction<IAiOutputTool>;
+export declare namespace AiOutputTool {
+    type Interface = IAiOutputTool;
+}
+export interface IAiOutputToolRegistry {
+    has(name: string): boolean;
+    invoke(name: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export declare const AiOutputToolRegistry: import("@webiny/di").Abstraction<IAiOutputToolRegistry>;
+export declare namespace AiOutputToolRegistry {
+    type Interface = IAiOutputToolRegistry;
+}
+export interface IAiToolPipelineRunner {
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const AiToolPipelineRunner: import("@webiny/di").Abstraction<IAiToolPipelineRunner>;
+export declare namespace AiToolPipelineRunner {
+    type Interface = IAiToolPipelineRunner;
+}

package/features/ai/toolPipeline/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/api";
+const AiOutputTool = createAbstraction("AiOutputTool");
+const AiOutputToolRegistry = createAbstraction("AiOutputToolRegistry");
+const AiToolPipelineRunner = createAbstraction("AiToolPipelineRunner");
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner };
+
+//# sourceMappingURL=abstractions.js.map

package/features/ai/toolPipeline/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/toolPipeline/abstractions.js","sources":["../../../../src/features/ai/toolPipeline/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IAiOutputTool {\n    readonly name: string;\n    execute(params: Record<string, unknown>): Promise<unknown>;\n}\n\nexport const AiOutputTool = createAbstraction<IAiOutputTool>(\"AiOutputTool\");\n\nexport namespace AiOutputTool {\n    export type Interface = IAiOutputTool;\n}\n\nexport interface IAiOutputToolRegistry {\n    has(name: string): boolean;\n    invoke(name: string, params: Record<string, unknown>): Promise<unknown>;\n}\n\nexport const AiOutputToolRegistry =\n    createAbstraction<IAiOutputToolRegistry>(\"AiOutputToolRegistry\");\n\nexport namespace AiOutputToolRegistry {\n    export type Interface = IAiOutputToolRegistry;\n}\n\nexport interface IAiToolPipelineRunner {\n    resolve(data: unknown): Promise<unknown>;\n}\n\nexport const AiToolPipelineRunner =\n    createAbstraction<IAiToolPipelineRunner>(\"AiToolPipelineRunner\");\n\nexport namespace AiToolPipelineRunner {\n    export type Interface = IAiToolPipelineRunner;\n}\n"],"names":["AiOutputTool","createAbstraction","AiOutputToolRegistry","AiToolPipelineRunner"],"mappings":";AAOO,MAAMA,eAAeC,kBAAiC;AAWtD,MAAMC,uBACTD,kBAAyC;AAUtC,MAAME,uBACTF,kBAAyC"}

package/features/ai/toolPipeline/index.d.ts

@@ -0,0 +1,2 @@
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./abstractions.js";
+export type { IAiOutputTool, IAiOutputToolRegistry, IAiToolPipelineRunner } from "./abstractions.js";

package/features/ai/toolPipeline/index.js

@@ -0,0 +1 @@
+export { AiOutputTool, AiOutputToolRegistry, AiToolPipelineRunner } from "./abstractions.js";

package/features/hashing/ScryptHasher.d.ts

@@ -0,0 +1,11 @@
+import type { IHasher } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+export declare class ScryptHasher implements IHasher {
+    private readonly cost;
+    private readonly pepper;
+    constructor(buildParams: BuildParams.Interface);
+    hash(value: string): Promise<string>;
+    verify(value: string, storedHash: string): Promise<boolean>;
+    private withPepper;
+}
+export declare const Hasher: import("@webiny/di").Implementation<typeof ScryptHasher>;

package/features/hashing/ScryptHasher.js

@@ -0,0 +1,74 @@
+import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { createImplementation } from "@webiny/feature/api";
+import { Hasher } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+const ScryptHasher_scrypt = (value, salt, keylen, options)=>new Promise((resolve, reject)=>{
+        scrypt(value, salt, keylen, options, (err, derivedKey)=>{
+            if (err) reject(err);
+            else resolve(derivedKey);
+        });
+    });
+const PREFIX = "scrypt";
+const KEYLEN = 64;
+const SALT_BYTES = 16;
+const DEFAULT_COST = {
+    N: 16384,
+    r: 8,
+    p: 1
+};
+class ScryptHasher {
+    constructor(buildParams){
+        this.pepper = buildParams.get("HashingPepper") ?? "";
+        const costN = buildParams.get("HashingCost");
+        this.cost = costN ? {
+            ...DEFAULT_COST,
+            N: Number(costN)
+        } : DEFAULT_COST;
+    }
+    async hash(value) {
+        const { N, r, p } = this.cost;
+        const salt = randomBytes(SALT_BYTES);
+        const derived = await ScryptHasher_scrypt(this.withPepper(value), salt, KEYLEN, {
+            N,
+            r,
+            p
+        });
+        return [
+            PREFIX,
+            N,
+            r,
+            p,
+            salt.toString("base64"),
+            derived.toString("base64")
+        ].join("$");
+    }
+    async verify(value, storedHash) {
+        const parts = storedHash.split("$");
+        if (6 !== parts.length || parts[0] !== PREFIX) return false;
+        const [, nRaw, rRaw, pRaw, saltB64, hashB64] = parts;
+        const N = Number(nRaw);
+        const r = Number(rRaw);
+        const p = Number(pRaw);
+        const salt = Buffer.from(saltB64, "base64");
+        const expected = Buffer.from(hashB64, "base64");
+        const derived = await ScryptHasher_scrypt(this.withPepper(value), salt, expected.length, {
+            N,
+            r,
+            p
+        });
+        return timingSafeEqual(derived, expected);
+    }
+    withPepper(value) {
+        return this.pepper ? `${value}${this.pepper}` : value;
+    }
+}
+const ScryptHasher_Hasher = createImplementation({
+    abstraction: Hasher,
+    implementation: ScryptHasher,
+    dependencies: [
+        BuildParams
+    ]
+});
+export { ScryptHasher, ScryptHasher_Hasher as Hasher };
+
+//# sourceMappingURL=ScryptHasher.js.map

package/features/hashing/ScryptHasher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hashing/ScryptHasher.js","sources":["../../../src/features/hashing/ScryptHasher.ts"],"sourcesContent":["import { randomBytes, scrypt as scryptCb, timingSafeEqual } from \"node:crypto\";\nimport type { ScryptOptions } from \"node:crypto\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { Hasher as HasherAbstraction } from \"./abstractions.js\";\nimport type { IHasher } from \"./abstractions.js\";\nimport { BuildParams } from \"../buildParams/abstractions.js\";\n\n// `promisify(scryptCb)` resolves to the no-options overload, so we wrap by hand\n// to keep the cost parameters (N, r, p).\nconst scrypt = (\n    value: string,\n    salt: Buffer,\n    keylen: number,\n    options: ScryptOptions\n): Promise<Buffer> =>\n    new Promise((resolve, reject) => {\n        scryptCb(value, salt, keylen, options, (err, derivedKey) => {\n            if (err) {\n                reject(err);\n            } else {\n                resolve(derivedKey);\n            }\n        });\n    });\n\n/**\n * Default hasher, built on Node's `crypto.scrypt` — no native dependency, so it runs anywhere Node\n * runs.\n *\n * Configuration (from `webiny.config.tsx` via `<Infra.Hashing>` → BuildParams):\n *  - `HashingPepper` — an optional server-side secret folded into every hash. Unlike the per-value\n *    salt (stored alongside the hash), the pepper is NOT stored, so a stolen database alone cannot\n *    be brute-forced without also holding the pepper. Changing it invalidates existing hashes (same\n *    trade-off as rotating the encryption passphrase). Omitted → no pepper, salt only.\n *  - `HashingCost` — optional override of the scrypt cost parameter N. Defaults to 16384.\n *\n * The stored value is self-describing (`scrypt$N$r$p$salt$hash`), so switching to Argon2id later is\n * a matter of registering a different `Hasher` — old scrypt hashes keep verifying.\n */\nconst PREFIX = \"scrypt\";\nconst KEYLEN = 64;\nconst SALT_BYTES = 16;\n\ninterface ScryptCost {\n    N: number;\n    r: number;\n    p: number;\n}\n\nconst DEFAULT_COST: ScryptCost = { N: 16384, r: 8, p: 1 };\n\nexport class ScryptHasher implements IHasher {\n    private readonly cost: ScryptCost;\n    private readonly pepper: string;\n\n    constructor(buildParams: BuildParams.Interface) {\n        this.pepper = buildParams.get<string>(\"HashingPepper\") ?? \"\";\n        const costN = buildParams.get<number | string>(\"HashingCost\");\n        this.cost = costN ? { ...DEFAULT_COST, N: Number(costN) } : DEFAULT_COST;\n    }\n\n    async hash(value: string): Promise<string> {\n        const { N, r, p } = this.cost;\n        const salt = randomBytes(SALT_BYTES);\n        const derived = (await scrypt(this.withPepper(value), salt, KEYLEN, { N, r, p })) as Buffer;\n\n        return [PREFIX, N, r, p, salt.toString(\"base64\"), derived.toString(\"base64\")].join(\"$\");\n    }\n\n    async verify(value: string, storedHash: string): Promise<boolean> {\n        const parts = storedHash.split(\"$\");\n        if (parts.length !== 6 || parts[0] !== PREFIX) {\n            return false;\n        }\n\n        const [, nRaw, rRaw, pRaw, saltB64, hashB64] = parts;\n        const N = Number(nRaw);\n        const r = Number(rRaw);\n        const p = Number(pRaw);\n        const salt = Buffer.from(saltB64, \"base64\");\n        const expected = Buffer.from(hashB64, \"base64\");\n\n        const derived = (await scrypt(this.withPepper(value), salt, expected.length, {\n            N,\n            r,\n            p\n        })) as Buffer;\n\n        // Lengths always match here, so timingSafeEqual is safe to call directly.\n        return timingSafeEqual(derived, expected);\n    }\n\n    private withPepper(value: string): string {\n        return this.pepper ? `${value}${this.pepper}` : value;\n    }\n}\n\nexport const Hasher = createImplementation({\n    abstraction: HasherAbstraction,\n    implementation: ScryptHasher,\n    dependencies: [BuildParams]\n});\n"],"names":["scrypt","value","salt","keylen","options","Promise","resolve","reject","scryptCb","err","derivedKey","PREFIX","KEYLEN","SALT_BYTES","DEFAULT_COST","ScryptHasher","buildParams","costN","Number","N","r","p","randomBytes","derived","storedHash","parts","nRaw","rRaw","pRaw","saltB64","hashB64","Buffer","expected","timingSafeEqual","Hasher","createImplementation","HasherAbstraction","BuildParams"],"mappings":";;;;AASA,MAAMA,sBAAS,CACXC,OACAC,MACAC,QACAC,UAEA,IAAIC,QAAQ,CAACC,SAASC;QAClBC,OAASP,OAAOC,MAAMC,QAAQC,SAAS,CAACK,KAAKC;YACzC,IAAID,KACAF,OAAOE;iBAEPH,QAAQI;QAEhB;IACJ;AAgBJ,MAAMC,SAAS;AACf,MAAMC,SAAS;AACf,MAAMC,aAAa;AAQnB,MAAMC,eAA2B;IAAE,GAAG;IAAO,GAAG;IAAG,GAAG;AAAE;AAEjD,MAAMC;IAIT,YAAYC,WAAkC,CAAE;QAC5C,IAAI,CAAC,MAAM,GAAGA,YAAY,GAAG,CAAS,oBAAoB;QAC1D,MAAMC,QAAQD,YAAY,GAAG,CAAkB;QAC/C,IAAI,CAAC,IAAI,GAAGC,QAAQ;YAAE,GAAGH,YAAY;YAAE,GAAGI,OAAOD;QAAO,IAAIH;IAChE;IAEA,MAAM,KAAKb,KAAa,EAAmB;QACvC,MAAM,EAAEkB,CAAC,EAAEC,CAAC,EAAEC,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI;QAC7B,MAAMnB,OAAOoB,YAAYT;QACzB,MAAMU,UAAW,MAAMvB,oBAAO,IAAI,CAAC,UAAU,CAACC,QAAQC,MAAMU,QAAQ;YAAEO;YAAGC;YAAGC;QAAE;QAE9E,OAAO;YAACV;YAAQQ;YAAGC;YAAGC;YAAGnB,KAAK,QAAQ,CAAC;YAAWqB,QAAQ,QAAQ,CAAC;SAAU,CAAC,IAAI,CAAC;IACvF;IAEA,MAAM,OAAOtB,KAAa,EAAEuB,UAAkB,EAAoB;QAC9D,MAAMC,QAAQD,WAAW,KAAK,CAAC;QAC/B,IAAIC,AAAiB,MAAjBA,MAAM,MAAM,IAAUA,KAAK,CAAC,EAAE,KAAKd,QACnC,OAAO;QAGX,MAAM,GAAGe,MAAMC,MAAMC,MAAMC,SAASC,QAAQ,GAAGL;QAC/C,MAAMN,IAAID,OAAOQ;QACjB,MAAMN,IAAIF,OAAOS;QACjB,MAAMN,IAAIH,OAAOU;QACjB,MAAM1B,OAAO6B,OAAO,IAAI,CAACF,SAAS;QAClC,MAAMG,WAAWD,OAAO,IAAI,CAACD,SAAS;QAEtC,MAAMP,UAAW,MAAMvB,oBAAO,IAAI,CAAC,UAAU,CAACC,QAAQC,MAAM8B,SAAS,MAAM,EAAE;YACzEb;YACAC;YACAC;QACJ;QAGA,OAAOY,gBAAgBV,SAASS;IACpC;IAEQ,WAAW/B,KAAa,EAAU;QACtC,OAAO,IAAI,CAAC,MAAM,GAAG,GAAGA,QAAQ,IAAI,CAAC,MAAM,EAAE,GAAGA;IACpD;AACJ;AAEO,MAAMiC,sBAASC,qBAAqB;IACvC,aAAaC;IACb,gBAAgBrB;IAChB,cAAc;QAACsB;KAAY;AAC/B"}

package/features/hashing/abstractions.d.ts

@@ -0,0 +1,18 @@
+export interface IHasher {
+    hash(value: string): Promise<string>;
+    /** Constant-time compare of `value` against a previously produced hash string. */
+    verify(value: string, storedHash: string): Promise<boolean>;
+}
+/**
+ * Hashes and verifies secret values (passwords, API-key secrets, tokens, …) with a slow, salted
+ * KDF — built for the "store a hash, later verify a presented value" pattern.
+ *
+ * NOT a general-purpose digest: output is salted and non-deterministic, so this is the wrong tool
+ * for checksums / cache keys / dedup (use a fast deterministic digest util for those). Swap the
+ * implementation to change algorithms (e.g. Argon2id); stored hashes are self-describing, so old
+ * hashes keep verifying after a swap.
+ */
+export declare const Hasher: import("@webiny/di").Abstraction<IHasher>;
+export declare namespace Hasher {
+    type Interface = IHasher;
+}

package/features/hashing/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const Hasher = createAbstraction("Hasher");
+export { Hasher };
+
+//# sourceMappingURL=abstractions.js.map

package/features/hashing/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hashing/abstractions.js","sources":["../../../src/features/hashing/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface IHasher {\n    hash(value: string): Promise<string>;\n    /** Constant-time compare of `value` against a previously produced hash string. */\n    verify(value: string, storedHash: string): Promise<boolean>;\n}\n\n/**\n * Hashes and verifies secret values (passwords, API-key secrets, tokens, …) with a slow, salted\n * KDF — built for the \"store a hash, later verify a presented value\" pattern.\n *\n * NOT a general-purpose digest: output is salted and non-deterministic, so this is the wrong tool\n * for checksums / cache keys / dedup (use a fast deterministic digest util for those). Swap the\n * implementation to change algorithms (e.g. Argon2id); stored hashes are self-describing, so old\n * hashes keep verifying after a swap.\n */\nexport const Hasher = createAbstraction<IHasher>(\"Hasher\");\n\nexport namespace Hasher {\n    export type Interface = IHasher;\n}\n"],"names":["Hasher","createAbstraction"],"mappings":";AAiBO,MAAMA,SAASC,kBAA2B"}

package/features/hashing/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const HasherFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/hashing/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { Hasher } from "./ScryptHasher.js";
+const HasherFeature = createFeature({
+    name: "HasherFeature",
+    register (container) {
+        container.register(Hasher);
+    }
+});
+export { HasherFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/hashing/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hashing/feature.js","sources":["../../../src/features/hashing/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Hasher } from \"./ScryptHasher.js\";\n\nexport const HasherFeature = createFeature({\n    name: \"HasherFeature\",\n    register(container) {\n        container.register(Hasher);\n    }\n});\n"],"names":["HasherFeature","createFeature","container","Hasher"],"mappings":";;AAGO,MAAMA,gBAAgBC,cAAc;IACvC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/hashing/index.d.ts

@@ -0,0 +1,2 @@
+export { Hasher } from "./abstractions.js";
+export type { IHasher } from "./abstractions.js";

package/features/hashing/index.js

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

package/features/requestContext/RawAuthToken.d.ts

@@ -0,0 +1,14 @@
+import type { IRawAuthToken } from "./abstractions.js";
+/**
+ * Per-request holder for the transport-extracted raw auth token. Registered per request, so a fresh
+ * instance holds the value for the current request only.
+ */
+declare class RawAuthTokenImpl implements IRawAuthToken {
+    private value;
+    get(): string | null;
+    set(token: string | null): void;
+}
+export declare const RawAuthToken: typeof RawAuthTokenImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IRawAuthToken>;
+};
+export {};

package/features/requestContext/RawAuthToken.js

@@ -0,0 +1,19 @@
+import { RawAuthToken } from "./abstractions.js";
+class RawAuthTokenImpl {
+    get() {
+        return this.value;
+    }
+    set(token) {
+        this.value = token;
+    }
+    constructor(){
+        this.value = null;
+    }
+}
+const RawAuthToken_RawAuthToken = RawAuthToken.createImplementation({
+    implementation: RawAuthTokenImpl,
+    dependencies: []
+});
+export { RawAuthToken_RawAuthToken as RawAuthToken };
+
+//# sourceMappingURL=RawAuthToken.js.map

package/features/requestContext/RawAuthToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/requestContext/RawAuthToken.js","sources":["../../../src/features/requestContext/RawAuthToken.ts"],"sourcesContent":["import { RawAuthToken as Abstraction } from \"./abstractions.js\";\nimport type { IRawAuthToken } from \"./abstractions.js\";\n\n/**\n * Per-request holder for the transport-extracted raw auth token. Registered per request, so a fresh\n * instance holds the value for the current request only.\n */\nclass RawAuthTokenImpl implements IRawAuthToken {\n    private value: string | null = null;\n\n    get(): string | null {\n        return this.value;\n    }\n\n    set(token: string | null): void {\n        this.value = token;\n    }\n}\n\nexport const RawAuthToken = Abstraction.createImplementation({\n    implementation: RawAuthTokenImpl,\n    dependencies: []\n});\n"],"names":["RawAuthTokenImpl","token","RawAuthToken","Abstraction"],"mappings":";AAOA,MAAMA;IAGF,MAAqB;QACjB,OAAO,IAAI,CAAC,KAAK;IACrB;IAEA,IAAIC,KAAoB,EAAQ;QAC5B,IAAI,CAAC,KAAK,GAAGA;IACjB;;aARQ,KAAK,GAAkB;;AASnC;AAEO,MAAMC,4BAAeC,aAAAA,oBAAgC,CAAC;IACzD,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/requestContext/RawTenantId.d.ts

@@ -0,0 +1,14 @@
+import type { IRawTenantId } from "./abstractions.js";
+/**
+ * Per-request holder for the transport-extracted raw tenant id. Registered per request, so a fresh
+ * instance holds the value for the current request only.
+ */
+declare class RawTenantIdImpl implements IRawTenantId {
+    private value;
+    get(): string | null;
+    set(id: string | null): void;
+}
+export declare const RawTenantId: typeof RawTenantIdImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IRawTenantId>;
+};
+export {};

package/features/requestContext/RawTenantId.js

@@ -0,0 +1,19 @@
+import { RawTenantId } from "./abstractions.js";
+class RawTenantIdImpl {
+    get() {
+        return this.value;
+    }
+    set(id) {
+        this.value = id;
+    }
+    constructor(){
+        this.value = null;
+    }
+}
+const RawTenantId_RawTenantId = RawTenantId.createImplementation({
+    implementation: RawTenantIdImpl,
+    dependencies: []
+});
+export { RawTenantId_RawTenantId as RawTenantId };
+
+//# sourceMappingURL=RawTenantId.js.map

package/features/requestContext/RawTenantId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/requestContext/RawTenantId.js","sources":["../../../src/features/requestContext/RawTenantId.ts"],"sourcesContent":["import { RawTenantId as Abstraction } from \"./abstractions.js\";\nimport type { IRawTenantId } from \"./abstractions.js\";\n\n/**\n * Per-request holder for the transport-extracted raw tenant id. Registered per request, so a fresh\n * instance holds the value for the current request only.\n */\nclass RawTenantIdImpl implements IRawTenantId {\n    private value: string | null = null;\n\n    get(): string | null {\n        return this.value;\n    }\n\n    set(id: string | null): void {\n        this.value = id;\n    }\n}\n\nexport const RawTenantId = Abstraction.createImplementation({\n    implementation: RawTenantIdImpl,\n    dependencies: []\n});\n"],"names":["RawTenantIdImpl","id","RawTenantId","Abstraction"],"mappings":";AAOA,MAAMA;IAGF,MAAqB;QACjB,OAAO,IAAI,CAAC,KAAK;IACrB;IAEA,IAAIC,EAAiB,EAAQ;QACzB,IAAI,CAAC,KAAK,GAAGA;IACjB;;aARQ,KAAK,GAAkB;;AASnC;AAEO,MAAMC,0BAAcC,YAAAA,oBAAgC,CAAC;IACxD,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/requestContext/RequestIdentityLoader.d.ts

@@ -0,0 +1,19 @@
+import { RequestIdentityLoader as Abstraction } from "./abstractions.js";
+import type { IRawAuthToken } from "./abstractions.js";
+import type { IAuthenticationContext } from "../../features/security/authentication/AuthenticationContext/index.js";
+import type { IIdentityContext } from "../../features/security/IdentityContext/abstractions.js";
+/**
+ * LOAD step: authenticates the token set by the transport's EXTRACT step into RawAuthToken and sets
+ * IdentityContext. A null/absent token authenticates as anonymous (preserves the previous
+ * always-authenticate-the-header behavior). Transport-agnostic.
+ */
+export declare class RequestIdentityLoaderImpl implements Abstraction.Interface {
+    private authentication;
+    private identityContext;
+    private rawAuthToken;
+    constructor(authentication: IAuthenticationContext, identityContext: IIdentityContext, rawAuthToken: IRawAuthToken);
+    establish(): Promise<void>;
+}
+export declare const RequestIdentityLoader: typeof RequestIdentityLoaderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IRequestIdentityLoader>;
+};

package/features/requestContext/RequestIdentityLoader.js

@@ -0,0 +1,26 @@
+import { RawAuthToken, RequestIdentityLoader } from "./abstractions.js";
+import { AuthenticationContext } from "../security/authentication/AuthenticationContext/index.js";
+import { IdentityContext } from "../security/IdentityContext/index.js";
+class RequestIdentityLoaderImpl {
+    constructor(authentication, identityContext, rawAuthToken){
+        this.authentication = authentication;
+        this.identityContext = identityContext;
+        this.rawAuthToken = rawAuthToken;
+    }
+    async establish() {
+        const token = this.rawAuthToken.get() ?? "";
+        const identity = await this.authentication.authenticate(token);
+        this.identityContext.setIdentity(identity);
+    }
+}
+const RequestIdentityLoader_RequestIdentityLoader = RequestIdentityLoader.createImplementation({
+    implementation: RequestIdentityLoaderImpl,
+    dependencies: [
+        AuthenticationContext,
+        IdentityContext,
+        RawAuthToken
+    ]
+});
+export { RequestIdentityLoaderImpl, RequestIdentityLoader_RequestIdentityLoader as RequestIdentityLoader };
+
+//# sourceMappingURL=RequestIdentityLoader.js.map

package/features/requestContext/RequestIdentityLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/requestContext/RequestIdentityLoader.js","sources":["../../../src/features/requestContext/RequestIdentityLoader.ts"],"sourcesContent":["import { RequestIdentityLoader as Abstraction, RawAuthToken } from \"./abstractions.js\";\nimport type { IRawAuthToken } from \"./abstractions.js\";\nimport { AuthenticationContext } from \"~/features/security/authentication/AuthenticationContext/index.js\";\nimport type { IAuthenticationContext } from \"~/features/security/authentication/AuthenticationContext/index.js\";\nimport { IdentityContext } from \"~/features/security/IdentityContext/index.js\";\nimport type { IIdentityContext } from \"~/features/security/IdentityContext/abstractions.js\";\n\n/**\n * LOAD step: authenticates the token set by the transport's EXTRACT step into RawAuthToken and sets\n * IdentityContext. A null/absent token authenticates as anonymous (preserves the previous\n * always-authenticate-the-header behavior). Transport-agnostic.\n */\nexport class RequestIdentityLoaderImpl implements Abstraction.Interface {\n    constructor(\n        private authentication: IAuthenticationContext,\n        private identityContext: IIdentityContext,\n        private rawAuthToken: IRawAuthToken\n    ) {}\n\n    async establish(): Promise<void> {\n        const token = this.rawAuthToken.get() ?? \"\";\n        const identity = await this.authentication.authenticate(token);\n        this.identityContext.setIdentity(identity);\n    }\n}\n\nexport const RequestIdentityLoader = Abstraction.createImplementation({\n    implementation: RequestIdentityLoaderImpl,\n    dependencies: [AuthenticationContext, IdentityContext, RawAuthToken]\n});\n"],"names":["RequestIdentityLoaderImpl","authentication","identityContext","rawAuthToken","token","identity","RequestIdentityLoader","Abstraction","AuthenticationContext","IdentityContext","RawAuthToken"],"mappings":";;;AAYO,MAAMA;IACT,YACYC,cAAsC,EACtCC,eAAiC,EACjCC,YAA2B,CACrC;aAHUF,cAAc,GAAdA;aACAC,eAAe,GAAfA;aACAC,YAAY,GAAZA;IACT;IAEH,MAAM,YAA2B;QAC7B,MAAMC,QAAQ,IAAI,CAAC,YAAY,CAAC,GAAG,MAAM;QACzC,MAAMC,WAAW,MAAM,IAAI,CAAC,cAAc,CAAC,YAAY,CAACD;QACxD,IAAI,CAAC,eAAe,CAAC,WAAW,CAACC;IACrC;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAAgC,CAAC;IAClE,gBAAgBP;IAChB,cAAc;QAACQ;QAAuBC;QAAiBC;KAAa;AACxE"}