@webiny/app-admin 0.0.0-unstable.e53eceafb5 → 0.0.0-unstable.e6f0dc8ca7

package/features/security/SecurityFeature.d.ts

@@ -0,0 +1 @@
+export declare const SecurityFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/features/security/SecurityFeature.js

@@ -0,0 +1,16 @@
+import { createFeature } from "@webiny/feature/admin";
+import { AuthenticationContextFeature } from "./AuthenticationContext/feature.js";
+import { IdentityContextFeature } from "./IdentityContext/feature.js";
+import { LogInFeature } from "./LogIn/feature.js";
+import { LogOutFeature } from "./LogOut/feature.js";
+export const SecurityFeature = createFeature({
+  name: "Security",
+  register(container) {
+    AuthenticationContextFeature.register(container);
+    IdentityContextFeature.register(container);
+    LogInFeature.register(container);
+    LogOutFeature.register(container);
+  }
+});
+
+//# sourceMappingURL=SecurityFeature.js.map

package/features/security/SecurityFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","AuthenticationContextFeature","IdentityContextFeature","LogInFeature","LogOutFeature","SecurityFeature","name","register","container"],"sources":["SecurityFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { AuthenticationContextFeature } from \"./AuthenticationContext/feature.js\";\nimport { IdentityContextFeature } from \"./IdentityContext/feature.js\";\nimport { LogInFeature } from \"./LogIn/feature.js\";\nimport { LogOutFeature } from \"./LogOut/feature.js\";\n\nexport const SecurityFeature = createFeature({\n    name: \"Security\",\n    register(container) {\n        AuthenticationContextFeature.register(container);\n        IdentityContextFeature.register(container);\n        LogInFeature.register(container);\n        LogOutFeature.register(container);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,uBAAuB;AACrD,SAASC,4BAA4B;AACrC,SAASC,sBAAsB;AAC/B,SAASC,YAAY;AACrB,SAASC,aAAa;AAEtB,OAAO,MAAMC,eAAe,GAAGL,aAAa,CAAC;EACzCM,IAAI,EAAE,UAAU;EAChBC,QAAQA,CAACC,SAAS,EAAE;IAChBP,4BAA4B,CAACM,QAAQ,CAACC,SAAS,CAAC;IAChDN,sBAAsB,CAACK,QAAQ,CAACC,SAAS,CAAC;IAC1CL,YAAY,CAACI,QAAQ,CAACC,SAAS,CAAC;IAChCJ,aAAa,CAACG,QAAQ,CAACC,SAAS,CAAC;EACrC;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/telemetry/TelemetryService.d.ts

@@ -0,0 +1,6 @@
+import { TelemetryService as Abstraction } from "./abstractions.js";
+declare class TelemetryServiceImpl implements Abstraction.Interface {
+    sendEvent(event: string, properties?: Record<string, any>): Promise<any>;
+}
+export declare const TelemetryService: import("@webiny/di").Implementation<typeof TelemetryServiceImpl>;
+export {};

package/features/telemetry/TelemetryService.js

@@ -0,0 +1,20 @@
+import { createImplementation } from "@webiny/di";
+import { sendEvent } from "@webiny/telemetry/react.js";
+import { TelemetryService as Abstraction } from "./abstractions.js";
+class TelemetryServiceImpl {
+  async sendEvent(event, properties) {
+    try {
+      console.debug("Telemetry:", event, properties);
+      await sendEvent(event, properties);
+    } catch {
+      // This ensures telemetry errors do not break the application.
+    }
+  }
+}
+export const TelemetryService = createImplementation({
+  abstraction: Abstraction,
+  implementation: TelemetryServiceImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=TelemetryService.js.map

package/features/telemetry/TelemetryService.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","sendEvent","TelemetryService","Abstraction","TelemetryServiceImpl","event","properties","console","debug","abstraction","implementation","dependencies"],"sources":["TelemetryService.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { sendEvent } from \"@webiny/telemetry/react.js\";\nimport { TelemetryService as Abstraction } from \"./abstractions.js\";\n\nclass TelemetryServiceImpl implements Abstraction.Interface {\n    async sendEvent(event: string, properties?: Record<string, any>): Promise<any> {\n        try {\n            console.debug(\"Telemetry:\", event, properties);\n            await sendEvent(event, properties);\n        } catch {\n            // This ensures telemetry errors do not break the application.\n        }\n    }\n}\n\nexport const TelemetryService = createImplementation({\n    abstraction: Abstraction,\n    implementation: TelemetryServiceImpl,\n    dependencies: []\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,YAAY;AACjD,SAASC,SAAS,QAAQ,4BAA4B;AACtD,SAASC,gBAAgB,IAAIC,WAAW;AAExC,MAAMC,oBAAoB,CAAkC;EACxD,MAAMH,SAASA,CAACI,KAAa,EAAEC,UAAgC,EAAgB;IAC3E,IAAI;MACAC,OAAO,CAACC,KAAK,CAAC,YAAY,EAAEH,KAAK,EAAEC,UAAU,CAAC;MAC9C,MAAML,SAAS,CAACI,KAAK,EAAEC,UAAU,CAAC;IACtC,CAAC,CAAC,MAAM;MACJ;IAAA;EAER;AACJ;AAEA,OAAO,MAAMJ,gBAAgB,GAAGF,oBAAoB,CAAC;EACjDS,WAAW,EAAEN,WAAW;EACxBO,cAAc,EAAEN,oBAAoB;EACpCO,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

package/features/telemetry/abstractions.d.ts

@@ -0,0 +1,7 @@
+export interface ITelemetryService {
+    sendEvent(event: string, properties?: Record<string, any>): Promise<any>;
+}
+export declare const TelemetryService: import("@webiny/di").Abstraction<ITelemetryService>;
+export declare namespace TelemetryService {
+    type Interface = ITelemetryService;
+}

package/features/telemetry/abstractions.js

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

package/features/telemetry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TelemetryService"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface ITelemetryService {\n    sendEvent(event: string, properties?: Record<string, any>): Promise<any>;\n}\n\nexport const TelemetryService = createAbstraction<ITelemetryService>(\"TelemetryService\");\n\nexport namespace TelemetryService {\n    export type Interface = ITelemetryService;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,uBAAuB;AAMzD,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,kBAAkB,CAAC","ignoreList":[]}

package/features/telemetry/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const TelemetryFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    service: import("./abstractions.js").ITelemetryService;
+}, []>;

package/features/telemetry/feature.js

@@ -0,0 +1,16 @@
+import { createFeature } from "@webiny/feature/admin";
+import { TelemetryService as TelemetryServiceAbstraction } from "./abstractions.js";
+import { TelemetryService } from "./TelemetryService.js";
+export const TelemetryFeature = createFeature({
+  name: "Telemetry",
+  register(container) {
+    container.register(TelemetryService).inSingletonScope();
+  },
+  resolve(container) {
+    return {
+      service: container.resolve(TelemetryServiceAbstraction)
+    };
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/telemetry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","TelemetryService","TelemetryServiceAbstraction","TelemetryFeature","name","register","container","inSingletonScope","resolve","service"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { TelemetryService as TelemetryServiceAbstraction } from \"./abstractions.js\";\nimport { TelemetryService } from \"./TelemetryService.js\";\n\nexport const TelemetryFeature = createFeature({\n    name: \"Telemetry\",\n    register(container) {\n        container.register(TelemetryService).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            service: container.resolve(TelemetryServiceAbstraction)\n        };\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,uBAAuB;AACrD,SAASC,gBAAgB,IAAIC,2BAA2B;AACxD,SAASD,gBAAgB;AAEzB,OAAO,MAAME,gBAAgB,GAAGH,aAAa,CAAC;EAC1CI,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACJ,gBAAgB,CAAC,CAACM,gBAAgB,CAAC,CAAC;EAC3D,CAAC;EACDC,OAAOA,CAACF,SAAS,EAAE;IACf,OAAO;MACHG,OAAO,EAAEH,SAAS,CAACE,OAAO,CAACN,2BAA2B;IAC1D,CAAC;EACL;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/telemetry/index.d.ts

@@ -0,0 +1,2 @@
+export { TelemetryFeature } from "./feature.js";
+export { TelemetryService } from "./abstractions.js";

package/features/telemetry/index.js

@@ -0,0 +1,4 @@
+export { TelemetryFeature } from "./feature.js";
+export { TelemetryService } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/telemetry/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TelemetryFeature","TelemetryService"],"sources":["index.ts"],"sourcesContent":["export { TelemetryFeature } from \"./feature.js\";\nexport { TelemetryService } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,gBAAgB","ignoreList":[]}

package/features/tenancy/GraphQLClientDecorator.d.ts

@@ -0,0 +1,12 @@
+import { GraphQLClient } from "@webiny/app/features/graphqlClient/index.js";
+import { TenantContext } from "../../features/tenancy/abstractions.js";
+declare class GraphQLClientWithTenantId implements GraphQLClient.Interface {
+    private context;
+    private decoratee;
+    constructor(context: TenantContext.Interface, decoratee: GraphQLClient.Interface);
+    execute<TVariables = any, TResult = any>(params: GraphQLClient.Request<TVariables>): Promise<TResult>;
+}
+export declare const GraphQLClientDecorator: typeof GraphQLClientWithTenantId & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/app/features/graphqlClient/abstractions").IGraphQLClient>;
+};
+export {};

package/features/tenancy/GraphQLClientDecorator.js

@@ -0,0 +1,27 @@
+import { GraphQLClient } from "@webiny/app/features/graphqlClient/index.js";
+import { TenantContext } from "./abstractions.js";
+class GraphQLClientWithTenantId {
+  constructor(context, decoratee) {
+    this.context = context;
+    this.decoratee = decoratee;
+  }
+  async execute(params) {
+    const tenant = this.context.getCurrentTenant();
+    const tenantHeaders = tenant ? {
+      "x-tenant": tenant
+    } : {};
+    return this.decoratee.execute({
+      ...params,
+      headers: {
+        ...params.headers,
+        ...tenantHeaders
+      }
+    });
+  }
+}
+export const GraphQLClientDecorator = GraphQLClient.createDecorator({
+  decorator: GraphQLClientWithTenantId,
+  dependencies: [TenantContext]
+});
+
+//# sourceMappingURL=GraphQLClientDecorator.js.map

package/features/tenancy/GraphQLClientDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GraphQLClient","TenantContext","GraphQLClientWithTenantId","constructor","context","decoratee","execute","params","tenant","getCurrentTenant","tenantHeaders","headers","GraphQLClientDecorator","createDecorator","decorator","dependencies"],"sources":["GraphQLClientDecorator.ts"],"sourcesContent":["import { GraphQLClient } from \"@webiny/app/features/graphqlClient/index.js\";\nimport { TenantContext } from \"~/features/tenancy/abstractions.js\";\n\nclass GraphQLClientWithTenantId implements GraphQLClient.Interface {\n    constructor(\n        private context: TenantContext.Interface,\n        private decoratee: GraphQLClient.Interface\n    ) {}\n\n    async execute<TVariables = any, TResult = any>(\n        params: GraphQLClient.Request<TVariables>\n    ): Promise<TResult> {\n        const tenant = this.context.getCurrentTenant();\n\n        const tenantHeaders = tenant ? { \"x-tenant\": tenant } : {};\n\n        return this.decoratee.execute({\n            ...params,\n            headers: { ...params.headers, ...tenantHeaders }\n        });\n    }\n}\n\nexport const GraphQLClientDecorator = GraphQLClient.createDecorator({\n    decorator: GraphQLClientWithTenantId,\n    dependencies: [TenantContext]\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,6CAA6C;AAC3E,SAASC,aAAa;AAEtB,MAAMC,yBAAyB,CAAoC;EAC/DC,WAAWA,CACCC,OAAgC,EAChCC,SAAkC,EAC5C;IAAA,KAFUD,OAAgC,GAAhCA,OAAgC;IAAA,KAChCC,SAAkC,GAAlCA,SAAkC;EAC3C;EAEH,MAAMC,OAAOA,CACTC,MAAyC,EACzB;IAChB,MAAMC,MAAM,GAAG,IAAI,CAACJ,OAAO,CAACK,gBAAgB,CAAC,CAAC;IAE9C,MAAMC,aAAa,GAAGF,MAAM,GAAG;MAAE,UAAU,EAAEA;IAAO,CAAC,GAAG,CAAC,CAAC;IAE1D,OAAO,IAAI,CAACH,SAAS,CAACC,OAAO,CAAC;MAC1B,GAAGC,MAAM;MACTI,OAAO,EAAE;QAAE,GAAGJ,MAAM,CAACI,OAAO;QAAE,GAAGD;MAAc;IACnD,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAME,sBAAsB,GAAGZ,aAAa,CAACa,eAAe,CAAC;EAChEC,SAAS,EAAEZ,yBAAyB;EACpCa,YAAY,EAAE,CAACd,aAAa;AAChC,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/TenantContext.d.ts

@@ -0,0 +1,17 @@
+import { TenantContext as Abstraction } from "./abstractions.js";
+import { LocalStorage } from "@webiny/app/features/localStorage";
+declare class TenantContextImpl implements Abstraction.Interface {
+    private localStorage;
+    private currentTenant;
+    private changeCallbacks;
+    constructor(localStorage: LocalStorage.Interface);
+    private initialize;
+    getCurrentTenant(): string | null;
+    setTenant(tenantId: string | null): void;
+    onTenantChange(callback: (tenantId: string | null) => void): () => void;
+    private notifyListeners;
+}
+export declare const TenantContext: typeof TenantContextImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITenantContext>;
+};
+export {};

package/features/tenancy/TenantContext.js

@@ -0,0 +1,61 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { TenantContext as Abstraction } from "./abstractions.js";
+import { LocalStorage } from "@webiny/app/features/localStorage";
+const LOCAL_STORAGE_KEY = "tenantId";
+const DEFAULT_TENANT = "root";
+class TenantContextImpl {
+  currentTenant = null;
+  changeCallbacks = new Set();
+  constructor(localStorage) {
+    this.localStorage = localStorage;
+    makeAutoObservable(this, {}, {
+      autoBind: true
+    });
+    this.initialize();
+  }
+  initialize() {
+    const storedTenant = this.localStorage.get(LOCAL_STORAGE_KEY) || DEFAULT_TENANT;
+    this.currentTenant = storedTenant;
+    this.localStorage.set(LOCAL_STORAGE_KEY, storedTenant);
+  }
+  getCurrentTenant() {
+    return this.currentTenant;
+  }
+  setTenant(tenantId) {
+    const previousTenant = this.currentTenant;
+    runInAction(() => {
+      this.currentTenant = tenantId;
+    });
+    if (tenantId) {
+      this.localStorage.set(LOCAL_STORAGE_KEY, tenantId);
+    } else {
+      this.localStorage.remove(LOCAL_STORAGE_KEY);
+    }
+
+    // Only notify if tenant actually changed
+    if (previousTenant !== tenantId) {
+      this.notifyListeners(tenantId);
+    }
+  }
+  onTenantChange(callback) {
+    this.changeCallbacks.add(callback);
+    return () => {
+      this.changeCallbacks.delete(callback);
+    };
+  }
+  notifyListeners(tenantId) {
+    this.changeCallbacks.forEach(callback => {
+      try {
+        callback(tenantId);
+      } catch (error) {
+        console.error("Tenant change callback error:", error);
+      }
+    });
+  }
+}
+export const TenantContext = Abstraction.createImplementation({
+  implementation: TenantContextImpl,
+  dependencies: [LocalStorage]
+});
+
+//# sourceMappingURL=TenantContext.js.map

package/features/tenancy/TenantContext.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["makeAutoObservable","runInAction","TenantContext","Abstraction","LocalStorage","LOCAL_STORAGE_KEY","DEFAULT_TENANT","TenantContextImpl","currentTenant","changeCallbacks","Set","constructor","localStorage","autoBind","initialize","storedTenant","get","set","getCurrentTenant","setTenant","tenantId","previousTenant","remove","notifyListeners","onTenantChange","callback","add","delete","forEach","error","console","createImplementation","implementation","dependencies"],"sources":["TenantContext.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport { TenantContext as Abstraction } from \"./abstractions.js\";\nimport { LocalStorage } from \"@webiny/app/features/localStorage\";\n\nconst LOCAL_STORAGE_KEY = \"tenantId\";\nconst DEFAULT_TENANT = \"root\";\n\nclass TenantContextImpl implements Abstraction.Interface {\n    private currentTenant: string | null = null;\n    private changeCallbacks = new Set<(tenantId: string | null) => void>();\n\n    constructor(private localStorage: LocalStorage.Interface) {\n        makeAutoObservable(this, {}, { autoBind: true });\n        this.initialize();\n    }\n\n    private initialize(): void {\n        const storedTenant = this.localStorage.get<string>(LOCAL_STORAGE_KEY) || DEFAULT_TENANT;\n        this.currentTenant = storedTenant;\n        this.localStorage.set(LOCAL_STORAGE_KEY, storedTenant);\n    }\n\n    getCurrentTenant(): string | null {\n        return this.currentTenant;\n    }\n\n    setTenant(tenantId: string | null): void {\n        const previousTenant = this.currentTenant;\n\n        runInAction(() => {\n            this.currentTenant = tenantId;\n        });\n\n        if (tenantId) {\n            this.localStorage.set(LOCAL_STORAGE_KEY, tenantId);\n        } else {\n            this.localStorage.remove(LOCAL_STORAGE_KEY);\n        }\n\n        // Only notify if tenant actually changed\n        if (previousTenant !== tenantId) {\n            this.notifyListeners(tenantId);\n        }\n    }\n\n    onTenantChange(callback: (tenantId: string | null) => void): () => void {\n        this.changeCallbacks.add(callback);\n        return () => {\n            this.changeCallbacks.delete(callback);\n        };\n    }\n\n    private notifyListeners(tenantId: string | null): void {\n        this.changeCallbacks.forEach(callback => {\n            try {\n                callback(tenantId);\n            } catch (error) {\n                console.error(\"Tenant change callback error:\", error);\n            }\n        });\n    }\n}\n\nexport const TenantContext = Abstraction.createImplementation({\n    implementation: TenantContextImpl,\n    dependencies: [LocalStorage]\n});\n"],"mappings":"AAAA,SAASA,kBAAkB,EAAEC,WAAW,QAAQ,MAAM;AACtD,SAASC,aAAa,IAAIC,WAAW;AACrC,SAASC,YAAY,QAAQ,mCAAmC;AAEhE,MAAMC,iBAAiB,GAAG,UAAU;AACpC,MAAMC,cAAc,GAAG,MAAM;AAE7B,MAAMC,iBAAiB,CAAkC;EAC7CC,aAAa,GAAkB,IAAI;EACnCC,eAAe,GAAG,IAAIC,GAAG,CAAoC,CAAC;EAEtEC,WAAWA,CAASC,YAAoC,EAAE;IAAA,KAAtCA,YAAoC,GAApCA,YAAoC;IACpDZ,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;MAAEa,QAAQ,EAAE;IAAK,CAAC,CAAC;IAChD,IAAI,CAACC,UAAU,CAAC,CAAC;EACrB;EAEQA,UAAUA,CAAA,EAAS;IACvB,MAAMC,YAAY,GAAG,IAAI,CAACH,YAAY,CAACI,GAAG,CAASX,iBAAiB,CAAC,IAAIC,cAAc;IACvF,IAAI,CAACE,aAAa,GAAGO,YAAY;IACjC,IAAI,CAACH,YAAY,CAACK,GAAG,CAACZ,iBAAiB,EAAEU,YAAY,CAAC;EAC1D;EAEAG,gBAAgBA,CAAA,EAAkB;IAC9B,OAAO,IAAI,CAACV,aAAa;EAC7B;EAEAW,SAASA,CAACC,QAAuB,EAAQ;IACrC,MAAMC,cAAc,GAAG,IAAI,CAACb,aAAa;IAEzCP,WAAW,CAAC,MAAM;MACd,IAAI,CAACO,aAAa,GAAGY,QAAQ;IACjC,CAAC,CAAC;IAEF,IAAIA,QAAQ,EAAE;MACV,IAAI,CAACR,YAAY,CAACK,GAAG,CAACZ,iBAAiB,EAAEe,QAAQ,CAAC;IACtD,CAAC,MAAM;MACH,IAAI,CAACR,YAAY,CAACU,MAAM,CAACjB,iBAAiB,CAAC;IAC/C;;IAEA;IACA,IAAIgB,cAAc,KAAKD,QAAQ,EAAE;MAC7B,IAAI,CAACG,eAAe,CAACH,QAAQ,CAAC;IAClC;EACJ;EAEAI,cAAcA,CAACC,QAA2C,EAAc;IACpE,IAAI,CAAChB,eAAe,CAACiB,GAAG,CAACD,QAAQ,CAAC;IAClC,OAAO,MAAM;MACT,IAAI,CAAChB,eAAe,CAACkB,MAAM,CAACF,QAAQ,CAAC;IACzC,CAAC;EACL;EAEQF,eAAeA,CAACH,QAAuB,EAAQ;IACnD,IAAI,CAACX,eAAe,CAACmB,OAAO,CAACH,QAAQ,IAAI;MACrC,IAAI;QACAA,QAAQ,CAACL,QAAQ,CAAC;MACtB,CAAC,CAAC,OAAOS,KAAK,EAAE;QACZC,OAAO,CAACD,KAAK,CAAC,+BAA+B,EAAEA,KAAK,CAAC;MACzD;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAM3B,aAAa,GAAGC,WAAW,CAAC4B,oBAAoB,CAAC;EAC1DC,cAAc,EAAEzB,iBAAiB;EACjC0B,YAAY,EAAE,CAAC7B,YAAY;AAC/B,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/abstractions.d.ts

@@ -0,0 +1,14 @@
+import { Abstraction } from "@webiny/di";
+export interface Tenant {
+    id: string;
+    name: string;
+}
+export interface ITenantContext {
+    getCurrentTenant(): string | null;
+    setTenant(tenantId: string | null): void;
+    onTenantChange(callback: (tenantId: string | null) => void): () => void;
+}
+export declare const TenantContext: Abstraction<ITenantContext>;
+export declare namespace TenantContext {
+    type Interface = ITenantContext;
+}

package/features/tenancy/abstractions.js

@@ -0,0 +1,4 @@
+import { Abstraction } from "@webiny/di";
+export const TenantContext = new Abstraction("TenantContext");
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Abstraction","TenantContext"],"sources":["abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\nexport interface Tenant {\n    id: string;\n    name: string;\n}\n\nexport interface ITenantContext {\n    getCurrentTenant(): string | null;\n    setTenant(tenantId: string | null): void;\n    onTenantChange(callback: (tenantId: string | null) => void): () => void;\n}\n\nexport const TenantContext = new Abstraction<ITenantContext>(\"TenantContext\");\n\nexport namespace TenantContext {\n    export type Interface = ITenantContext;\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,YAAY;AAaxC,OAAO,MAAMC,aAAa,GAAG,IAAID,WAAW,CAAiB,eAAe,CAAC","ignoreList":[]}

package/features/tenancy/feature.d.ts

@@ -0,0 +1,5 @@
+import { Container } from "@webiny/di";
+export declare const TenancyFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    service: import("./abstractions.js").ITenantContext;
+    createTenantContainer: () => Container;
+}, []>;

package/features/tenancy/feature.js

@@ -0,0 +1,41 @@
+import { createFeature } from "@webiny/feature/admin";
+import { LocalStorageFeature } from "@webiny/app/features/localStorage/feature.js";
+import { TenantContext as TenantContextAbstraction } from "./abstractions.js";
+import { TenantContext } from "./TenantContext.js";
+import { GraphQLClientDecorator } from "./GraphQLClientDecorator.js";
+export const TenancyFeature = createFeature({
+  name: "Tenancy",
+  register(container) {
+    container.register(TenantContext).inSingletonScope();
+    container.registerDecorator(GraphQLClientDecorator);
+  },
+  resolve(container) {
+    const service = container.resolve(TenantContextAbstraction);
+    return {
+      service,
+      // Helper to create tenant-scoped container
+      createTenantContainer: () => {
+        const currentTenant = service.getCurrentTenant();
+        if (!currentTenant) {
+          return container;
+        }
+
+        // Get current localStorage config
+        const {
+          localStorageConfig
+        } = LocalStorageFeature.resolve(container);
+
+        // Create tenant-scoped child container
+        const tenantContainer = container.createChildContainer();
+
+        // Re-register localStorage with tenant-specific prefix
+        LocalStorageFeature.register(tenantContainer, {
+          prefix: `${localStorageConfig.prefix}/${currentTenant}`
+        });
+        return tenantContainer;
+      }
+    };
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/tenancy/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","LocalStorageFeature","TenantContext","TenantContextAbstraction","GraphQLClientDecorator","TenancyFeature","name","register","container","inSingletonScope","registerDecorator","resolve","service","createTenantContainer","currentTenant","getCurrentTenant","localStorageConfig","tenantContainer","createChildContainer","prefix"],"sources":["feature.ts"],"sourcesContent":["import { Container } from \"@webiny/di\";\nimport { createFeature } from \"@webiny/feature/admin\";\nimport { LocalStorageFeature } from \"@webiny/app/features/localStorage/feature.js\";\nimport { TenantContext as TenantContextAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"./TenantContext.js\";\nimport { GraphQLClientDecorator } from \"./GraphQLClientDecorator.js\";\n\nexport const TenancyFeature = createFeature({\n    name: \"Tenancy\",\n    register(container: Container) {\n        container.register(TenantContext).inSingletonScope();\n        container.registerDecorator(GraphQLClientDecorator);\n    },\n    resolve(container: Container) {\n        const service = container.resolve(TenantContextAbstraction);\n\n        return {\n            service,\n\n            // Helper to create tenant-scoped container\n            createTenantContainer: () => {\n                const currentTenant = service.getCurrentTenant();\n\n                if (!currentTenant) {\n                    return container;\n                }\n\n                // Get current localStorage config\n                const { localStorageConfig } = LocalStorageFeature.resolve(container);\n\n                // Create tenant-scoped child container\n                const tenantContainer = container.createChildContainer();\n\n                // Re-register localStorage with tenant-specific prefix\n                LocalStorageFeature.register(tenantContainer, {\n                    prefix: `${localStorageConfig.prefix}/${currentTenant}`\n                });\n\n                return tenantContainer;\n            }\n        };\n    }\n});\n"],"mappings":"AACA,SAASA,aAAa,QAAQ,uBAAuB;AACrD,SAASC,mBAAmB,QAAQ,8CAA8C;AAClF,SAASC,aAAa,IAAIC,wBAAwB;AAClD,SAASD,aAAa;AACtB,SAASE,sBAAsB;AAE/B,OAAO,MAAMC,cAAc,GAAGL,aAAa,CAAC;EACxCM,IAAI,EAAE,SAAS;EACfC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,aAAa,CAAC,CAACO,gBAAgB,CAAC,CAAC;IACpDD,SAAS,CAACE,iBAAiB,CAACN,sBAAsB,CAAC;EACvD,CAAC;EACDO,OAAOA,CAACH,SAAoB,EAAE;IAC1B,MAAMI,OAAO,GAAGJ,SAAS,CAACG,OAAO,CAACR,wBAAwB,CAAC;IAE3D,OAAO;MACHS,OAAO;MAEP;MACAC,qBAAqB,EAAEA,CAAA,KAAM;QACzB,MAAMC,aAAa,GAAGF,OAAO,CAACG,gBAAgB,CAAC,CAAC;QAEhD,IAAI,CAACD,aAAa,EAAE;UAChB,OAAON,SAAS;QACpB;;QAEA;QACA,MAAM;UAAEQ;QAAmB,CAAC,GAAGf,mBAAmB,CAACU,OAAO,CAACH,SAAS,CAAC;;QAErE;QACA,MAAMS,eAAe,GAAGT,SAAS,CAACU,oBAAoB,CAAC,CAAC;;QAExD;QACAjB,mBAAmB,CAACM,QAAQ,CAACU,eAAe,EAAE;UAC1CE,MAAM,EAAE,GAAGH,kBAAkB,CAACG,MAAM,IAAIL,aAAa;QACzD,CAAC,CAAC;QAEF,OAAOG,eAAe;MAC1B;IACJ,CAAC;EACL;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/types.d.ts

@@ -0,0 +1,4 @@
+export interface Tenant {
+    id: string;
+    name: string;
+}

package/features/tenancy/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=types.js.map

package/features/tenancy/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export interface Tenant {\n    id: string;\n    name: string;\n}\n"],"mappings":"","ignoreList":[]}

package/features/tools/LexicalContext/LexicalContext.d.ts

@@ -0,0 +1,14 @@
+import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from "lexical";
+import { LexicalContext as Abstraction } from "./abstractions.js";
+declare class LexicalContextImpl implements Abstraction.Interface {
+    private nodes;
+    private theme;
+    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;
+    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void;
+    getTheme(): EditorThemeClasses | undefined;
+    setTheme(theme: EditorThemeClasses): void;
+}
+export declare const LexicalContext: typeof LexicalContextImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILexicalContext>;
+};
+export {};

package/features/tools/LexicalContext/LexicalContext.js

@@ -0,0 +1,22 @@
+import { LexicalContext as Abstraction } from "./abstractions.js";
+class LexicalContextImpl {
+  nodes = [];
+  getNodes() {
+    return this.nodes;
+  }
+  setNodes(nodes) {
+    this.nodes = nodes;
+  }
+  getTheme() {
+    return this.theme;
+  }
+  setTheme(theme) {
+    this.theme = theme;
+  }
+}
+export const LexicalContext = Abstraction.createImplementation({
+  implementation: LexicalContextImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=LexicalContext.js.map

package/features/tools/LexicalContext/LexicalContext.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LexicalContext","Abstraction","LexicalContextImpl","nodes","getNodes","setNodes","getTheme","theme","setTheme","createImplementation","implementation","dependencies"],"sources":["LexicalContext.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from \"lexical\";\nimport { LexicalContext as Abstraction } from \"./abstractions.js\";\n\nclass LexicalContextImpl implements Abstraction.Interface {\n    private nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement> = [];\n    private theme: EditorThemeClasses | undefined;\n\n    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement> {\n        return this.nodes;\n    }\n\n    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void {\n        this.nodes = nodes;\n    }\n\n    getTheme(): EditorThemeClasses | undefined {\n        return this.theme;\n    }\n\n    setTheme(theme: EditorThemeClasses): void {\n        this.theme = theme;\n    }\n}\n\nexport const LexicalContext = Abstraction.createImplementation({\n    implementation: LexicalContextImpl,\n    dependencies: []\n});\n"],"mappings":"AACA,SAASA,cAAc,IAAIC,WAAW;AAEtC,MAAMC,kBAAkB,CAAkC;EAC9CC,KAAK,GAA+D,EAAE;EAG9EC,QAAQA,CAAA,EAA+D;IACnE,OAAO,IAAI,CAACD,KAAK;EACrB;EAEAE,QAAQA,CAACF,KAAiE,EAAQ;IAC9E,IAAI,CAACA,KAAK,GAAGA,KAAK;EACtB;EAEAG,QAAQA,CAAA,EAAmC;IACvC,OAAO,IAAI,CAACC,KAAK;EACrB;EAEAC,QAAQA,CAACD,KAAyB,EAAQ;IACtC,IAAI,CAACA,KAAK,GAAGA,KAAK;EACtB;AACJ;AAEA,OAAO,MAAMP,cAAc,GAAGC,WAAW,CAACQ,oBAAoB,CAAC;EAC3DC,cAAc,EAAER,kBAAkB;EAClCS,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

package/features/tools/LexicalContext/abstractions.d.ts

@@ -0,0 +1,11 @@
+import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from "lexical";
+export interface ILexicalContext {
+    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;
+    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void;
+    getTheme(): EditorThemeClasses | undefined;
+    setTheme(theme: EditorThemeClasses): void;
+}
+export declare const LexicalContext: import("@webiny/di").Abstraction<ILexicalContext>;
+export declare namespace LexicalContext {
+    type Interface = ILexicalContext;
+}

package/features/tools/LexicalContext/abstractions.js

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

package/features/tools/LexicalContext/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","LexicalContext"],"sources":["abstractions.ts"],"sourcesContent":["import type { Klass, LexicalNode, LexicalNodeReplacement, EditorThemeClasses } from \"lexical\";\nimport { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface ILexicalContext {\n    getNodes(): ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>;\n    setNodes(nodes: ReadonlyArray<Klass<LexicalNode> | LexicalNodeReplacement>): void;\n    getTheme(): EditorThemeClasses | undefined;\n    setTheme(theme: EditorThemeClasses): void;\n}\n\nexport const LexicalContext = createAbstraction<ILexicalContext>(\"LexicalContext\");\n\nexport namespace LexicalContext {\n    export type Interface = ILexicalContext;\n}\n"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,uBAAuB;AASzD,OAAO,MAAMC,cAAc,GAAGD,iBAAiB,CAAkB,gBAAgB,CAAC","ignoreList":[]}

package/features/tools/LexicalContext/index.d.ts

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

package/features/tools/LexicalContext/index.js

@@ -0,0 +1,3 @@
+export { LexicalContext } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/tools/LexicalContext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LexicalContext"],"sources":["index.ts"],"sourcesContent":["export { LexicalContext } from \"./abstractions.js\";\nexport type { ILexicalContext } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,cAAc","ignoreList":[]}

package/features/tools/ToolPipelineRunner.d.ts

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

package/features/tools/ToolPipelineRunner.js

@@ -0,0 +1,33 @@
+import { ToolPipelineRunner as Abstraction, ToolRegistry } from "./abstractions.js";
+function isToolEnvelope(value) {
+  return typeof value === "object" && value !== null && "tool" in value && typeof value.tool === "string" && "params" in value && typeof value.params === "object";
+}
+class PipelineRunnerImpl {
+  constructor(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  async resolve(data) {
+    if (data === null || data === undefined) {
+      return data;
+    }
+    if (isToolEnvelope(data)) {
+      const result = await this.toolRegistry.invoke(data.tool, data.params);
+      return this.resolve(result);
+    }
+    if (Array.isArray(data)) {
+      return Promise.all(data.map(item => this.resolve(item)));
+    }
+    if (typeof data === "object") {
+      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;
+  }
+}
+export const ToolPipelineRunner = Abstraction.createImplementation({
+  implementation: PipelineRunnerImpl,
+  dependencies: [ToolRegistry]
+});
+
+//# sourceMappingURL=ToolPipelineRunner.js.map

package/features/tools/ToolPipelineRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ToolPipelineRunner","Abstraction","ToolRegistry","isToolEnvelope","value","tool","params","PipelineRunnerImpl","constructor","toolRegistry","resolve","data","undefined","result","invoke","Array","isArray","Promise","all","map","item","entries","Object","resolvedValues","fromEntries","key","i","createImplementation","implementation","dependencies"],"sources":["ToolPipelineRunner.ts"],"sourcesContent":["import {\n    ToolPipelineRunner as Abstraction,\n    ToolRegistry,\n    type IToolPipelineRunner,\n    type IToolRegistry\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 PipelineRunnerImpl implements IToolPipelineRunner {\n    constructor(private toolRegistry: IToolRegistry) {}\n\n    async resolve(data: unknown): Promise<unknown> {\n        if (data === null || data === undefined) {\n            return data;\n        }\n\n        if (isToolEnvelope(data)) {\n            const result = await this.toolRegistry.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 ToolPipelineRunner = Abstraction.createImplementation({\n    implementation: PipelineRunnerImpl,\n    dependencies: [ToolRegistry]\n});\n"],"mappings":"AAAA,SACIA,kBAAkB,IAAIC,WAAW,EACjCC,YAAY;AAKhB,SAASC,cAAcA,CACnBC,KAAc,EAC4C;EAC1D,OACI,OAAOA,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,IAAI,IACd,MAAM,IAAIA,KAAK,IACf,OAAQA,KAAK,CAA6BC,IAAI,KAAK,QAAQ,IAC3D,QAAQ,IAAID,KAAK,IACjB,OAAQA,KAAK,CAA6BE,MAAM,KAAK,QAAQ;AAErE;AAEA,MAAMC,kBAAkB,CAAgC;EACpDC,WAAWA,CAASC,YAA2B,EAAE;IAAA,KAA7BA,YAA2B,GAA3BA,YAA2B;EAAG;EAElD,MAAMC,OAAOA,CAACC,IAAa,EAAoB;IAC3C,IAAIA,IAAI,KAAK,IAAI,IAAIA,IAAI,KAAKC,SAAS,EAAE;MACrC,OAAOD,IAAI;IACf;IAEA,IAAIR,cAAc,CAACQ,IAAI,CAAC,EAAE;MACtB,MAAME,MAAM,GAAG,MAAM,IAAI,CAACJ,YAAY,CAACK,MAAM,CAACH,IAAI,CAACN,IAAI,EAAEM,IAAI,CAACL,MAAM,CAAC;MACrE,OAAO,IAAI,CAACI,OAAO,CAACG,MAAM,CAAC;IAC/B;IAEA,IAAIE,KAAK,CAACC,OAAO,CAACL,IAAI,CAAC,EAAE;MACrB,OAAOM,OAAO,CAACC,GAAG,CAACP,IAAI,CAACQ,GAAG,CAACC,IAAI,IAAI,IAAI,CAACV,OAAO,CAACU,IAAI,CAAC,CAAC,CAAC;IAC5D;IAEA,IAAI,OAAOT,IAAI,KAAK,QAAQ,EAAE;MAC1B,MAAMU,OAAO,GAAGC,MAAM,CAACD,OAAO,CAACV,IAA+B,CAAC;MAC/D,MAAMY,cAAc,GAAG,MAAMN,OAAO,CAACC,GAAG,CACpCG,OAAO,CAACF,GAAG,CAAC,CAAC,GAAGf,KAAK,CAAC,KAAK,IAAI,CAACM,OAAO,CAACN,KAAK,CAAC,CAClD,CAAC;MACD,OAAOkB,MAAM,CAACE,WAAW,CAACH,OAAO,CAACF,GAAG,CAAC,CAAC,CAACM,GAAG,CAAC,EAAEC,CAAC,KAAK,CAACD,GAAG,EAAEF,cAAc,CAACG,CAAC,CAAC,CAAC,CAAC,CAAC;IAClF;IAEA,OAAOf,IAAI;EACf;AACJ;AAEA,OAAO,MAAMX,kBAAkB,GAAGC,WAAW,CAAC0B,oBAAoB,CAAC;EAC/DC,cAAc,EAAErB,kBAAkB;EAClCsB,YAAY,EAAE,CAAC3B,YAAY;AAC/B,CAAC,CAAC","ignoreList":[]}

package/features/tools/ToolRegistry.d.ts

@@ -0,0 +1,12 @@
+import { type ITool, type IToolRegistry } from "./abstractions.js";
+declare class ToolRegistryImpl implements IToolRegistry {
+    private toolMap;
+    constructor(tools: ITool[]);
+    getTool(name: string): ITool;
+    getTools(): ITool[];
+    invoke(name: string, params: unknown): Promise<unknown>;
+}
+export declare const ToolRegistry: typeof ToolRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IToolRegistry>;
+};
+export {};

package/features/tools/ToolRegistry.js

@@ -0,0 +1,29 @@
+import { Tool, ToolRegistry as ToolRegistryAbstraction } from "./abstractions.js";
+class ToolRegistryImpl {
+  constructor(tools) {
+    this.toolMap = new Map(tools.map(t => [t.name, t]));
+  }
+  getTool(name) {
+    const tool = this.toolMap.get(name);
+    if (!tool) {
+      throw new Error(`Tool "${name}" is not registered.`);
+    }
+    return tool;
+  }
+  getTools() {
+    return [...this.toolMap.values()];
+  }
+  async invoke(name, params) {
+    const tool = this.getTool(name);
+    const validated = tool.inputSchema.parse(params);
+    return tool.execute(validated);
+  }
+}
+export const ToolRegistry = ToolRegistryAbstraction.createImplementation({
+  implementation: ToolRegistryImpl,
+  dependencies: [[Tool, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=ToolRegistry.js.map

package/features/tools/ToolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Tool","ToolRegistry","ToolRegistryAbstraction","ToolRegistryImpl","constructor","tools","toolMap","Map","map","t","name","getTool","tool","get","Error","getTools","values","invoke","params","validated","inputSchema","parse","execute","createImplementation","implementation","dependencies","multiple"],"sources":["ToolRegistry.ts"],"sourcesContent":["import {\n    Tool,\n    ToolRegistry as ToolRegistryAbstraction,\n    type ITool,\n    type IToolRegistry\n} from \"./abstractions.js\";\n\nclass ToolRegistryImpl implements IToolRegistry {\n    private toolMap: Map<string, ITool>;\n\n    constructor(tools: ITool[]) {\n        this.toolMap = new Map(tools.map(t => [t.name, t]));\n    }\n\n    getTool(name: string): ITool {\n        const tool = this.toolMap.get(name);\n        if (!tool) {\n            throw new Error(`Tool \"${name}\" is not registered.`);\n        }\n        return tool;\n    }\n\n    getTools(): ITool[] {\n        return [...this.toolMap.values()];\n    }\n\n    async invoke(name: string, params: unknown): Promise<unknown> {\n        const tool = this.getTool(name);\n        const validated = tool.inputSchema.parse(params);\n        return tool.execute(validated);\n    }\n}\n\nexport const ToolRegistry = ToolRegistryAbstraction.createImplementation({\n    implementation: ToolRegistryImpl,\n    dependencies: [[Tool, { multiple: true }]]\n});\n"],"mappings":"AAAA,SACIA,IAAI,EACJC,YAAY,IAAIC,uBAAuB;AAK3C,MAAMC,gBAAgB,CAA0B;EAG5CC,WAAWA,CAACC,KAAc,EAAE;IACxB,IAAI,CAACC,OAAO,GAAG,IAAIC,GAAG,CAACF,KAAK,CAACG,GAAG,CAACC,CAAC,IAAI,CAACA,CAAC,CAACC,IAAI,EAAED,CAAC,CAAC,CAAC,CAAC;EACvD;EAEAE,OAAOA,CAACD,IAAY,EAAS;IACzB,MAAME,IAAI,GAAG,IAAI,CAACN,OAAO,CAACO,GAAG,CAACH,IAAI,CAAC;IACnC,IAAI,CAACE,IAAI,EAAE;MACP,MAAM,IAAIE,KAAK,CAAC,SAASJ,IAAI,sBAAsB,CAAC;IACxD;IACA,OAAOE,IAAI;EACf;EAEAG,QAAQA,CAAA,EAAY;IAChB,OAAO,CAAC,GAAG,IAAI,CAACT,OAAO,CAACU,MAAM,CAAC,CAAC,CAAC;EACrC;EAEA,MAAMC,MAAMA,CAACP,IAAY,EAAEQ,MAAe,EAAoB;IAC1D,MAAMN,IAAI,GAAG,IAAI,CAACD,OAAO,CAACD,IAAI,CAAC;IAC/B,MAAMS,SAAS,GAAGP,IAAI,CAACQ,WAAW,CAACC,KAAK,CAACH,MAAM,CAAC;IAChD,OAAON,IAAI,CAACU,OAAO,CAACH,SAAS,CAAC;EAClC;AACJ;AAEA,OAAO,MAAMlB,YAAY,GAAGC,uBAAuB,CAACqB,oBAAoB,CAAC;EACrEC,cAAc,EAAErB,gBAAgB;EAChCsB,YAAY,EAAE,CAAC,CAACzB,IAAI,EAAE;IAAE0B,QAAQ,EAAE;EAAK,CAAC,CAAC;AAC7C,CAAC,CAAC","ignoreList":[]}

package/features/tools/abstractions.d.ts

@@ -0,0 +1,28 @@
+import type { z } from "zod";
+export interface ITool<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> {
+    name: string;
+    description: string;
+    inputSchema: TInput;
+    outputSchema: TOutput;
+    execute(input: z.infer<TInput>): Promise<z.infer<TOutput>>;
+}
+export declare const Tool: import("@webiny/di").Abstraction<ITool<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
+export declare namespace Tool {
+    type Interface<TInput extends z.ZodType = z.ZodType, TOutput extends z.ZodType = z.ZodType> = ITool<TInput, TOutput>;
+}
+export interface IToolRegistry {
+    getTool(name: string): ITool;
+    getTools(): ITool[];
+    invoke(name: string, params: unknown): Promise<unknown>;
+}
+export declare const ToolRegistry: import("@webiny/di").Abstraction<IToolRegistry>;
+export declare namespace ToolRegistry {
+    type Interface = IToolRegistry;
+}
+export interface IToolPipelineRunner {
+    resolve(data: unknown): Promise<unknown>;
+}
+export declare const ToolPipelineRunner: import("@webiny/di").Abstraction<IToolPipelineRunner>;
+export declare namespace ToolPipelineRunner {
+    type Interface = IToolPipelineRunner;
+}

package/features/tools/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+export const Tool = createAbstraction("Tool");
+export const ToolRegistry = createAbstraction("ToolRegistry");
+export const ToolPipelineRunner = createAbstraction("ToolPipelineRunner");
+
+//# sourceMappingURL=abstractions.js.map

package/features/tools/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","Tool","ToolRegistry","ToolPipelineRunner"],"sources":["abstractions.ts"],"sourcesContent":["import type { z } from \"zod\";\nimport { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface ITool<\n    TInput extends z.ZodType = z.ZodType,\n    TOutput extends z.ZodType = z.ZodType\n> {\n    name: string;\n    description: string;\n    inputSchema: TInput;\n    outputSchema: TOutput;\n    execute(input: z.infer<TInput>): Promise<z.infer<TOutput>>;\n}\n\nexport const Tool = createAbstraction<ITool>(\"Tool\");\n\nexport namespace Tool {\n    export type Interface<\n        TInput extends z.ZodType = z.ZodType,\n        TOutput extends z.ZodType = z.ZodType\n    > = ITool<TInput, TOutput>;\n}\n\nexport interface IToolRegistry {\n    getTool(name: string): ITool;\n    getTools(): ITool[];\n    invoke(name: string, params: unknown): Promise<unknown>;\n}\n\nexport const ToolRegistry = createAbstraction<IToolRegistry>(\"ToolRegistry\");\n\nexport namespace ToolRegistry {\n    export type Interface = IToolRegistry;\n}\n\nexport interface IToolPipelineRunner {\n    resolve(data: unknown): Promise<unknown>;\n}\n\nexport const ToolPipelineRunner = createAbstraction<IToolPipelineRunner>(\"ToolPipelineRunner\");\n\nexport namespace ToolPipelineRunner {\n    export type Interface = IToolPipelineRunner;\n}\n"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,uBAAuB;AAazD,OAAO,MAAMC,IAAI,GAAGD,iBAAiB,CAAQ,MAAM,CAAC;AAepD,OAAO,MAAME,YAAY,GAAGF,iBAAiB,CAAgB,cAAc,CAAC;AAU5E,OAAO,MAAMG,kBAAkB,GAAGH,iBAAiB,CAAsB,oBAAoB,CAAC","ignoreList":[]}

package/features/tools/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ToolsFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    toolRegistry: import("./abstractions.js").IToolRegistry;
+    pipelineRunner: import("./abstractions.js").IToolPipelineRunner;
+}, []>;