@webiny/api-core 0.0.0-unstable.3c5210ad37

package/features/eventPublisher/abstractions.js

@@ -0,0 +1,14 @@
+import { Abstraction } from "@webiny/di";
+export class DomainEvent {
+  constructor(payload) {
+    this.occurredAt = new Date();
+    if (payload === undefined) {
+      this.payload = undefined;
+    } else {
+      this.payload = payload;
+    }
+  }
+}
+export const EventPublisher = new Abstraction("EventPublisher");
+
+//# sourceMappingURL=abstractions.js.map

package/features/eventPublisher/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Abstraction","DomainEvent","constructor","payload","occurredAt","Date","undefined","EventPublisher"],"sources":["abstractions.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\n\nexport abstract class DomainEvent<TPayload = void> {\n    public abstract readonly eventType: string;\n    public readonly occurredAt: Date;\n    public readonly payload: TPayload extends void ? undefined : TPayload;\n\n    constructor(payload: TPayload);\n    constructor(payload?: never) {\n        this.occurredAt = new Date();\n\n        if (payload === undefined) {\n            this.payload = undefined as any;\n        } else {\n            this.payload = payload;\n        }\n    }\n\n    abstract getHandlerAbstraction(): Abstraction<IEventHandler<any>>;\n}\n\nexport interface IEventHandler<TEvent extends DomainEvent<any> = DomainEvent<any>> {\n    handle(event: TEvent): Promise<void>;\n}\n\nexport interface IEventPublisher {\n    publish<TEvent extends DomainEvent<any>>(event: TEvent): Promise<void>;\n}\n\nexport const EventPublisher = new Abstraction<IEventPublisher>(\"EventPublisher\");\n\nexport namespace EventPublisher {\n    export type Interface = IEventPublisher;\n}\n"],"mappings":"AAAA,SAASA,WAAW,QAAQ,YAAY;AAExC,OAAO,MAAeC,WAAW,CAAkB;EAM/CC,WAAWA,CAACC,OAAe,EAAE;IACzB,IAAI,CAACC,UAAU,GAAG,IAAIC,IAAI,CAAC,CAAC;IAE5B,IAAIF,OAAO,KAAKG,SAAS,EAAE;MACvB,IAAI,CAACH,OAAO,GAAGG,SAAgB;IACnC,CAAC,MAAM;MACH,IAAI,CAACH,OAAO,GAAGA,OAAO;IAC1B;EACJ;AAGJ;AAUA,OAAO,MAAMI,cAAc,GAAG,IAAIP,WAAW,CAAkB,gBAAgB,CAAC","ignoreList":[]}

package/features/eventPublisher/feature.d.ts

@@ -0,0 +1 @@
+export declare const EventPublisherFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/eventPublisher/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { EventPublisher as EventPublisherAbstraction } from "./abstractions.js";
+import { EventPublisher } from "./EventPublisher.js";
+export const EventPublisherFeature = createFeature({
+  name: "EventPublisher",
+  register(container) {
+    container.registerInstance(EventPublisherAbstraction, new EventPublisher(container));
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/eventPublisher/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","EventPublisher","EventPublisherAbstraction","EventPublisherFeature","name","register","container","registerInstance"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { Container } from \"@webiny/di\";\nimport { EventPublisher as EventPublisherAbstraction } from \"./abstractions.js\";\nimport { EventPublisher } from \"./EventPublisher.js\";\n\nexport const EventPublisherFeature = createFeature({\n    name: \"EventPublisher\",\n    register(container: Container) {\n        container.registerInstance(EventPublisherAbstraction, new EventPublisher(container));\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,cAAc,IAAIC,yBAAyB;AACpD,SAASD,cAAc;AAEvB,OAAO,MAAME,qBAAqB,GAAGH,aAAa,CAAC;EAC/CI,IAAI,EAAE,gBAAgB;EACtBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACC,gBAAgB,CAACL,yBAAyB,EAAE,IAAID,cAAc,CAACK,SAAS,CAAC,CAAC;EACxF;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/eventPublisher/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/eventPublisher/index.js

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

package/features/eventPublisher/index.js.map

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

package/features/featureFlags/FeatureFlags.d.ts

@@ -0,0 +1,12 @@
+import { FeatureFlags as FeatureFlagsAbstraction } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+import { FeatureFlags as FeatureFlagsClass } from "@webiny/feature-flags";
+declare class FeatureFlagsImpl implements FeatureFlagsAbstraction.Interface {
+    private buildParams;
+    constructor(buildParams: BuildParams.Interface);
+    get(): FeatureFlagsClass;
+}
+export declare const FeatureFlags: typeof FeatureFlagsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IFeatureFlagsAbstraction>;
+};
+export {};

package/features/featureFlags/FeatureFlags.js

@@ -0,0 +1,18 @@
+import { FeatureFlags as FeatureFlagsAbstraction } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+import { FeatureFlags as FeatureFlagsClass } from "@webiny/feature-flags";
+class FeatureFlagsImpl {
+  constructor(buildParams) {
+    this.buildParams = buildParams;
+  }
+  get() {
+    const raw = this.buildParams.get("FeatureFlags") ?? {};
+    return FeatureFlagsClass.fromDto(raw);
+  }
+}
+export const FeatureFlags = FeatureFlagsAbstraction.createImplementation({
+  implementation: FeatureFlagsImpl,
+  dependencies: [BuildParams]
+});
+
+//# sourceMappingURL=FeatureFlags.js.map

package/features/featureFlags/FeatureFlags.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FeatureFlags","FeatureFlagsAbstraction","BuildParams","FeatureFlagsClass","FeatureFlagsImpl","constructor","buildParams","get","raw","fromDto","createImplementation","implementation","dependencies"],"sources":["FeatureFlags.ts"],"sourcesContent":["import { FeatureFlags as FeatureFlagsAbstraction } from \"./abstractions.js\";\nimport { BuildParams } from \"../buildParams/abstractions.js\";\nimport { FeatureFlags as FeatureFlagsClass } from \"@webiny/feature-flags\";\nimport type { IFeatureFlagsDto } from \"@webiny/feature-flags\";\n\nclass FeatureFlagsImpl implements FeatureFlagsAbstraction.Interface {\n    constructor(private buildParams: BuildParams.Interface) {}\n\n    get(): FeatureFlagsClass {\n        const raw = this.buildParams.get<IFeatureFlagsDto>(\"FeatureFlags\") ?? {};\n        return FeatureFlagsClass.fromDto(raw);\n    }\n}\n\nexport const FeatureFlags = FeatureFlagsAbstraction.createImplementation({\n    implementation: FeatureFlagsImpl,\n    dependencies: [BuildParams]\n});\n"],"mappings":"AAAA,SAASA,YAAY,IAAIC,uBAAuB;AAChD,SAASC,WAAW;AACpB,SAASF,YAAY,IAAIG,iBAAiB,QAAQ,uBAAuB;AAGzE,MAAMC,gBAAgB,CAA8C;EAChEC,WAAWA,CAASC,WAAkC,EAAE;IAAA,KAApCA,WAAkC,GAAlCA,WAAkC;EAAG;EAEzDC,GAAGA,CAAA,EAAsB;IACrB,MAAMC,GAAG,GAAG,IAAI,CAACF,WAAW,CAACC,GAAG,CAAmB,cAAc,CAAC,IAAI,CAAC,CAAC;IACxE,OAAOJ,iBAAiB,CAACM,OAAO,CAACD,GAAG,CAAC;EACzC;AACJ;AAEA,OAAO,MAAMR,YAAY,GAAGC,uBAAuB,CAACS,oBAAoB,CAAC;EACrEC,cAAc,EAAEP,gBAAgB;EAChCQ,YAAY,EAAE,CAACV,WAAW;AAC9B,CAAC,CAAC","ignoreList":[]}

package/features/featureFlags/abstractions.d.ts

@@ -0,0 +1,8 @@
+import { FeatureFlags as FeatureFlagsClass } from "@webiny/feature-flags";
+export interface IFeatureFlagsAbstraction {
+    get(): FeatureFlagsClass;
+}
+export declare const FeatureFlags: import("@webiny/di").Abstraction<IFeatureFlagsAbstraction>;
+export declare namespace FeatureFlags {
+    type Interface = IFeatureFlagsAbstraction;
+}

package/features/featureFlags/abstractions.js

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

package/features/featureFlags/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","FeatureFlags"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { FeatureFlags as FeatureFlagsClass } from \"@webiny/feature-flags\";\n\nexport interface IFeatureFlagsAbstraction {\n    get(): FeatureFlagsClass;\n}\n\nexport const FeatureFlags = createAbstraction<IFeatureFlagsAbstraction>(\"FeatureFlags\");\n\nexport namespace FeatureFlags {\n    export type Interface = IFeatureFlagsAbstraction;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAOvD,OAAO,MAAMC,YAAY,GAAGD,iBAAiB,CAA2B,cAAc,CAAC","ignoreList":[]}

package/features/featureFlags/feature.d.ts

@@ -0,0 +1 @@
+export declare const FeatureFlagsFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/featureFlags/feature.js

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

package/features/featureFlags/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","FeatureFlags","FeatureFlagsFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { FeatureFlags } from \"./FeatureFlags.js\";\n\nexport const FeatureFlagsFeature = createFeature({\n    name: \"FeatureFlags\",\n    register(container: Container) {\n        container.register(FeatureFlags);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,YAAY;AAErB,OAAO,MAAMC,mBAAmB,GAAGF,aAAa,CAAC;EAC7CG,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACH,YAAY,CAAC;EACpC;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/keyValueStore/GlobalKeyValueStore.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStoreRepository, GlobalKeyValueStore as ServiceAbstraction, IGlobalKeyValueStoreOptions } from "./abstractions.js";
+declare class GlobalKeyValueStoreImpl implements ServiceAbstraction.Interface {
+    private repository;
+    constructor(repository: KeyValueStoreRepository.Interface);
+    private getScope;
+    get<T = unknown>(key: string, options?: IGlobalKeyValueStoreOptions): Promise<Result<T, ServiceAbstraction.Error>>;
+    set(key: string, value: any, options?: IGlobalKeyValueStoreOptions): Promise<Result<void, ServiceAbstraction.Error>>;
+    delete(key: string, options?: IGlobalKeyValueStoreOptions): Promise<Result<void, ServiceAbstraction.Error>>;
+}
+export declare const GlobalKeyValueStore: import("@webiny/di").Implementation<typeof GlobalKeyValueStoreImpl>;
+export {};

package/features/keyValueStore/GlobalKeyValueStore.js

@@ -0,0 +1,30 @@
+import { createImplementation } from "@webiny/feature/api";
+import { KeyValueStoreRepository, GlobalKeyValueStore as ServiceAbstraction } from "./abstractions.js";
+const DEFAULT_SCOPE = "global";
+class GlobalKeyValueStoreImpl {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  getScope(options) {
+    return options?.scope || DEFAULT_SCOPE;
+  }
+  async get(key, options) {
+    const scope = this.getScope(options);
+    return this.repository.get(key, scope);
+  }
+  async set(key, value, options) {
+    const scope = this.getScope(options);
+    return this.repository.set(key, value, scope);
+  }
+  async delete(key, options) {
+    const scope = this.getScope(options);
+    return this.repository.delete(key, scope);
+  }
+}
+export const GlobalKeyValueStore = createImplementation({
+  abstraction: ServiceAbstraction,
+  implementation: GlobalKeyValueStoreImpl,
+  dependencies: [KeyValueStoreRepository]
+});
+
+//# sourceMappingURL=GlobalKeyValueStore.js.map

package/features/keyValueStore/GlobalKeyValueStore.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","KeyValueStoreRepository","GlobalKeyValueStore","ServiceAbstraction","DEFAULT_SCOPE","GlobalKeyValueStoreImpl","constructor","repository","getScope","options","scope","get","key","set","value","delete","abstraction","implementation","dependencies"],"sources":["GlobalKeyValueStore.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport {\n    KeyValueStoreRepository,\n    GlobalKeyValueStore as ServiceAbstraction,\n    IGlobalKeyValueStoreOptions\n} from \"./abstractions.js\";\n\nconst DEFAULT_SCOPE = \"global\";\n\nclass GlobalKeyValueStoreImpl implements ServiceAbstraction.Interface {\n    constructor(private repository: KeyValueStoreRepository.Interface) {}\n\n    private getScope(options?: IGlobalKeyValueStoreOptions): string {\n        return options?.scope || DEFAULT_SCOPE;\n    }\n\n    async get<T = unknown>(\n        key: string,\n        options?: IGlobalKeyValueStoreOptions\n    ): Promise<Result<T, ServiceAbstraction.Error>> {\n        const scope = this.getScope(options);\n        return this.repository.get<T>(key, scope);\n    }\n\n    async set(\n        key: string,\n        value: any,\n        options?: IGlobalKeyValueStoreOptions\n    ): Promise<Result<void, ServiceAbstraction.Error>> {\n        const scope = this.getScope(options);\n        return this.repository.set(key, value, scope);\n    }\n\n    async delete(\n        key: string,\n        options?: IGlobalKeyValueStoreOptions\n    ): Promise<Result<void, ServiceAbstraction.Error>> {\n        const scope = this.getScope(options);\n        return this.repository.delete(key, scope);\n    }\n}\n\nexport const GlobalKeyValueStore = createImplementation({\n    abstraction: ServiceAbstraction,\n    implementation: GlobalKeyValueStoreImpl,\n    dependencies: [KeyValueStoreRepository]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAE1D,SACIC,uBAAuB,EACvBC,mBAAmB,IAAIC,kBAAkB;AAI7C,MAAMC,aAAa,GAAG,QAAQ;AAE9B,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CAASC,UAA6C,EAAE;IAAA,KAA/CA,UAA6C,GAA7CA,UAA6C;EAAG;EAE5DC,QAAQA,CAACC,OAAqC,EAAU;IAC5D,OAAOA,OAAO,EAAEC,KAAK,IAAIN,aAAa;EAC1C;EAEA,MAAMO,GAAGA,CACLC,GAAW,EACXH,OAAqC,EACO;IAC5C,MAAMC,KAAK,GAAG,IAAI,CAACF,QAAQ,CAACC,OAAO,CAAC;IACpC,OAAO,IAAI,CAACF,UAAU,CAACI,GAAG,CAAIC,GAAG,EAAEF,KAAK,CAAC;EAC7C;EAEA,MAAMG,GAAGA,CACLD,GAAW,EACXE,KAAU,EACVL,OAAqC,EACU;IAC/C,MAAMC,KAAK,GAAG,IAAI,CAACF,QAAQ,CAACC,OAAO,CAAC;IACpC,OAAO,IAAI,CAACF,UAAU,CAACM,GAAG,CAACD,GAAG,EAAEE,KAAK,EAAEJ,KAAK,CAAC;EACjD;EAEA,MAAMK,MAAMA,CACRH,GAAW,EACXH,OAAqC,EACU;IAC/C,MAAMC,KAAK,GAAG,IAAI,CAACF,QAAQ,CAACC,OAAO,CAAC;IACpC,OAAO,IAAI,CAACF,UAAU,CAACQ,MAAM,CAACH,GAAG,EAAEF,KAAK,CAAC;EAC7C;AACJ;AAEA,OAAO,MAAMR,mBAAmB,GAAGF,oBAAoB,CAAC;EACpDgB,WAAW,EAAEb,kBAAkB;EAC/Bc,cAAc,EAAEZ,uBAAuB;EACvCa,YAAY,EAAE,CAACjB,uBAAuB;AAC1C,CAAC,CAAC","ignoreList":[]}

package/features/keyValueStore/KeyValueStore.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStore as ServiceAbstraction } from "./abstractions.js";
+import { GlobalKeyValueStore } from "./abstractions.js";
+import { TenantContext } from "../../features/tenancy/TenantContext/index.js";
+declare class KeyValueStoreImpl implements ServiceAbstraction.Interface {
+    private tenantContext;
+    private globalStore;
+    constructor(tenantContext: TenantContext.Interface, globalStore: GlobalKeyValueStore.Interface);
+    get<T = unknown>(key: string): Promise<Result<T, ServiceAbstraction.Error>>;
+    set(key: string, value: any): Promise<Result<void, ServiceAbstraction.Error>>;
+    delete(key: string): Promise<Result<void, ServiceAbstraction.Error>>;
+}
+export declare const KeyValueStore: typeof KeyValueStoreImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IKeyValueStore>;
+};
+export {};

package/features/keyValueStore/KeyValueStore.js

@@ -0,0 +1,33 @@
+import { KeyValueStore as ServiceAbstraction } from "./abstractions.js";
+import { GlobalKeyValueStore } from "./abstractions.js";
+import { TenantContext } from "../tenancy/TenantContext/index.js";
+class KeyValueStoreImpl {
+  constructor(tenantContext, globalStore) {
+    this.tenantContext = tenantContext;
+    this.globalStore = globalStore;
+  }
+  async get(key) {
+    const tenant = this.tenantContext.getTenant();
+    return this.globalStore.get(key, {
+      scope: tenant.id
+    });
+  }
+  async set(key, value) {
+    const tenant = this.tenantContext.getTenant();
+    return this.globalStore.set(key, value, {
+      scope: tenant.id
+    });
+  }
+  async delete(key) {
+    const tenant = this.tenantContext.getTenant();
+    return this.globalStore.delete(key, {
+      scope: tenant.id
+    });
+  }
+}
+export const KeyValueStore = ServiceAbstraction.createImplementation({
+  implementation: KeyValueStoreImpl,
+  dependencies: [TenantContext, GlobalKeyValueStore]
+});
+
+//# sourceMappingURL=KeyValueStore.js.map

package/features/keyValueStore/KeyValueStore.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["KeyValueStore","ServiceAbstraction","GlobalKeyValueStore","TenantContext","KeyValueStoreImpl","constructor","tenantContext","globalStore","get","key","tenant","getTenant","scope","id","set","value","delete","createImplementation","implementation","dependencies"],"sources":["KeyValueStore.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { KeyValueStore as ServiceAbstraction } from \"./abstractions.js\";\nimport { GlobalKeyValueStore } from \"./abstractions.js\";\nimport { TenantContext } from \"~/features/tenancy/TenantContext/index.js\";\n\nclass KeyValueStoreImpl implements ServiceAbstraction.Interface {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private globalStore: GlobalKeyValueStore.Interface\n    ) {}\n\n    async get<T = unknown>(key: string): Promise<Result<T, ServiceAbstraction.Error>> {\n        const tenant = this.tenantContext.getTenant();\n        return this.globalStore.get<T>(key, { scope: tenant.id });\n    }\n\n    async set(key: string, value: any): Promise<Result<void, ServiceAbstraction.Error>> {\n        const tenant = this.tenantContext.getTenant();\n        return this.globalStore.set(key, value, { scope: tenant.id });\n    }\n\n    async delete(key: string): Promise<Result<void, ServiceAbstraction.Error>> {\n        const tenant = this.tenantContext.getTenant();\n        return this.globalStore.delete(key, { scope: tenant.id });\n    }\n}\n\nexport const KeyValueStore = ServiceAbstraction.createImplementation({\n    implementation: KeyValueStoreImpl,\n    dependencies: [TenantContext, GlobalKeyValueStore]\n});\n"],"mappings":"AACA,SAASA,aAAa,IAAIC,kBAAkB;AAC5C,SAASC,mBAAmB;AAC5B,SAASC,aAAa;AAEtB,MAAMC,iBAAiB,CAAyC;EAC5DC,WAAWA,CACCC,aAAsC,EACtCC,WAA0C,EACpD;IAAA,KAFUD,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,WAA0C,GAA1CA,WAA0C;EACnD;EAEH,MAAMC,GAAGA,CAAcC,GAAW,EAAgD;IAC9E,MAAMC,MAAM,GAAG,IAAI,CAACJ,aAAa,CAACK,SAAS,CAAC,CAAC;IAC7C,OAAO,IAAI,CAACJ,WAAW,CAACC,GAAG,CAAIC,GAAG,EAAE;MAAEG,KAAK,EAAEF,MAAM,CAACG;IAAG,CAAC,CAAC;EAC7D;EAEA,MAAMC,GAAGA,CAACL,GAAW,EAAEM,KAAU,EAAmD;IAChF,MAAML,MAAM,GAAG,IAAI,CAACJ,aAAa,CAACK,SAAS,CAAC,CAAC;IAC7C,OAAO,IAAI,CAACJ,WAAW,CAACO,GAAG,CAACL,GAAG,EAAEM,KAAK,EAAE;MAAEH,KAAK,EAAEF,MAAM,CAACG;IAAG,CAAC,CAAC;EACjE;EAEA,MAAMG,MAAMA,CAACP,GAAW,EAAmD;IACvE,MAAMC,MAAM,GAAG,IAAI,CAACJ,aAAa,CAACK,SAAS,CAAC,CAAC;IAC7C,OAAO,IAAI,CAACJ,WAAW,CAACS,MAAM,CAACP,GAAG,EAAE;MAAEG,KAAK,EAAEF,MAAM,CAACG;IAAG,CAAC,CAAC;EAC7D;AACJ;AAEA,OAAO,MAAMb,aAAa,GAAGC,kBAAkB,CAACgB,oBAAoB,CAAC;EACjEC,cAAc,EAAEd,iBAAiB;EACjCe,YAAY,EAAE,CAAChB,aAAa,EAAED,mBAAmB;AACrD,CAAC,CAAC","ignoreList":[]}

package/features/keyValueStore/KeyValueStoreRepository.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStorageOperations, KeyValueStoreRepository as RepositoryAbstraction } from "./abstractions.js";
+/**
+ * KeyValueStoreRepository implementation.
+ *
+ * This repository passes key and scope separately to storage operations.
+ * The storage layer is responsible for handling scope-based partitioning.
+ */
+declare class KeyValueStoreRepositoryImpl implements RepositoryAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: KeyValueStorageOperations.Interface);
+    get<T = unknown>(key: string, scope: string): Promise<Result<T, RepositoryAbstraction.Error>>;
+    set(key: string, value: any, scope: string): Promise<Result<void, RepositoryAbstraction.Error>>;
+    delete(key: string, scope: string): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const KeyValueStoreRepository: import("@webiny/di").Implementation<typeof KeyValueStoreRepositoryImpl>;
+export {};

package/features/keyValueStore/KeyValueStoreRepository.js

@@ -0,0 +1,50 @@
+import { createImplementation } from "@webiny/feature/api";
+import { Result } from "@webiny/feature/api";
+import { KeyValueStorageOperations, KeyValueStoreRepository as RepositoryAbstraction } from "./abstractions.js";
+import { KeyNotFoundError, KeyValueStorageError } from "./errors.js";
+
+/**
+ * KeyValueStoreRepository implementation.
+ *
+ * This repository passes key and scope separately to storage operations.
+ * The storage layer is responsible for handling scope-based partitioning.
+ */
+class KeyValueStoreRepositoryImpl {
+  constructor(storageOperations) {
+    this.storageOperations = storageOperations;
+  }
+  async get(key, scope) {
+    try {
+      const record = await this.storageOperations.get(key, scope);
+      if (!record) {
+        return Result.fail(new KeyNotFoundError(key));
+      }
+      return Result.ok(record.value);
+    } catch (error) {
+      return Result.fail(new KeyValueStorageError(error));
+    }
+  }
+  async set(key, value, scope) {
+    try {
+      await this.storageOperations.set(key, value, scope);
+      return Result.ok();
+    } catch (error) {
+      return Result.fail(new KeyValueStorageError(error));
+    }
+  }
+  async delete(key, scope) {
+    try {
+      await this.storageOperations.delete(key, scope);
+      return Result.ok();
+    } catch (error) {
+      return Result.fail(new KeyValueStorageError(error));
+    }
+  }
+}
+export const KeyValueStoreRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: KeyValueStoreRepositoryImpl,
+  dependencies: [KeyValueStorageOperations]
+});
+
+//# sourceMappingURL=KeyValueStoreRepository.js.map

package/features/keyValueStore/KeyValueStoreRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","KeyValueStorageOperations","KeyValueStoreRepository","RepositoryAbstraction","KeyNotFoundError","KeyValueStorageError","KeyValueStoreRepositoryImpl","constructor","storageOperations","get","key","scope","record","fail","ok","value","error","set","delete","abstraction","implementation","dependencies"],"sources":["KeyValueStoreRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport {\n    KeyValueStorageOperations,\n    KeyValueStoreRepository as RepositoryAbstraction\n} from \"./abstractions.js\";\nimport { KeyNotFoundError, KeyValueStorageError } from \"./errors.js\";\n\n/**\n * KeyValueStoreRepository implementation.\n *\n * This repository passes key and scope separately to storage operations.\n * The storage layer is responsible for handling scope-based partitioning.\n */\nclass KeyValueStoreRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(private storageOperations: KeyValueStorageOperations.Interface) {}\n\n    async get<T = unknown>(\n        key: string,\n        scope: string\n    ): Promise<Result<T, RepositoryAbstraction.Error>> {\n        try {\n            const record = await this.storageOperations.get(key, scope);\n\n            if (!record) {\n                return Result.fail(new KeyNotFoundError(key));\n            }\n\n            return Result.ok(record.value as T);\n        } catch (error) {\n            return Result.fail(new KeyValueStorageError(error as Error));\n        }\n    }\n\n    async set(\n        key: string,\n        value: any,\n        scope: string\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            await this.storageOperations.set(key, value, scope);\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new KeyValueStorageError(error as Error));\n        }\n    }\n\n    async delete(key: string, scope: string): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            await this.storageOperations.delete(key, scope);\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(new KeyValueStorageError(error as Error));\n        }\n    }\n}\n\nexport const KeyValueStoreRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: KeyValueStoreRepositoryImpl,\n    dependencies: [KeyValueStorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SACIC,yBAAyB,EACzBC,uBAAuB,IAAIC,qBAAqB;AAEpD,SAASC,gBAAgB,EAAEC,oBAAoB;;AAE/C;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,2BAA2B,CAA4C;EACzEC,WAAWA,CAASC,iBAAsD,EAAE;IAAA,KAAxDA,iBAAsD,GAAtDA,iBAAsD;EAAG;EAE7E,MAAMC,GAAGA,CACLC,GAAW,EACXC,KAAa,EACkC;IAC/C,IAAI;MACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,iBAAiB,CAACC,GAAG,CAACC,GAAG,EAAEC,KAAK,CAAC;MAE3D,IAAI,CAACC,MAAM,EAAE;QACT,OAAOZ,MAAM,CAACa,IAAI,CAAC,IAAIT,gBAAgB,CAACM,GAAG,CAAC,CAAC;MACjD;MAEA,OAAOV,MAAM,CAACc,EAAE,CAACF,MAAM,CAACG,KAAU,CAAC;IACvC,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ,OAAOhB,MAAM,CAACa,IAAI,CAAC,IAAIR,oBAAoB,CAACW,KAAc,CAAC,CAAC;IAChE;EACJ;EAEA,MAAMC,GAAGA,CACLP,GAAW,EACXK,KAAU,EACVJ,KAAa,EACqC;IAClD,IAAI;MACA,MAAM,IAAI,CAACH,iBAAiB,CAACS,GAAG,CAACP,GAAG,EAAEK,KAAK,EAAEJ,KAAK,CAAC;MACnD,OAAOX,MAAM,CAACc,EAAE,CAAC,CAAC;IACtB,CAAC,CAAC,OAAOE,KAAK,EAAE;MACZ,OAAOhB,MAAM,CAACa,IAAI,CAAC,IAAIR,oBAAoB,CAACW,KAAc,CAAC,CAAC;IAChE;EACJ;EAEA,MAAME,MAAMA,CAACR,GAAW,EAAEC,KAAa,EAAsD;IACzF,IAAI;MACA,MAAM,IAAI,CAACH,iBAAiB,CAACU,MAAM,CAACR,GAAG,EAAEC,KAAK,CAAC;MAC/C,OAAOX,MAAM,CAACc,EAAE,CAAC,CAAC;IACtB,CAAC,CAAC,OAAOE,KAAK,EAAE;MACZ,OAAOhB,MAAM,CAACa,IAAI,CAAC,IAAIR,oBAAoB,CAACW,KAAc,CAAC,CAAC;IAChE;EACJ;AACJ;AAEA,OAAO,MAAMd,uBAAuB,GAAGH,oBAAoB,CAAC;EACxDoB,WAAW,EAAEhB,qBAAqB;EAClCiB,cAAc,EAAEd,2BAA2B;EAC3Ce,YAAY,EAAE,CAACpB,yBAAyB;AAC5C,CAAC,CAAC","ignoreList":[]}

package/features/keyValueStore/abstractions.d.ts

@@ -0,0 +1,58 @@
+import { Result } from "@webiny/feature/api";
+import { KeyNotFoundError, KeyValueStorageError } from "./errors.js";
+export interface IKeyValueRecord {
+    key: string;
+    value: any;
+}
+export interface IGlobalKeyValueStoreOptions {
+    scope?: string;
+}
+export interface IGlobalKeyValueStore {
+    get<T = unknown>(key: string, options?: IGlobalKeyValueStoreOptions): Promise<Result<T, KeyValueStoreRepository.Error>>;
+    set(key: string, value: any, options?: IGlobalKeyValueStoreOptions): Promise<Result<void, KeyValueStoreRepository.Error>>;
+    delete(key: string, options?: IGlobalKeyValueStoreOptions): Promise<Result<void, KeyValueStoreRepository.Error>>;
+}
+export declare const GlobalKeyValueStore: import("@webiny/di").Abstraction<IGlobalKeyValueStore>;
+export declare namespace GlobalKeyValueStore {
+    type Interface = IGlobalKeyValueStore;
+    type KeyValueRecord = IKeyValueRecord;
+    type Error = KeyValueStoreRepository.Error;
+}
+export interface IKeyValueStore {
+    get<T = unknown>(key: string): Promise<Result<T, KeyValueStoreRepository.Error>>;
+    set(key: string, value: any): Promise<Result<void, KeyValueStoreRepository.Error>>;
+    delete(key: string): Promise<Result<void, KeyValueStoreRepository.Error>>;
+}
+export declare const KeyValueStore: import("@webiny/di").Abstraction<IKeyValueStore>;
+export declare namespace KeyValueStore {
+    type Interface = IKeyValueStore;
+    type KeyValueRecord = IKeyValueRecord;
+    type Error = KeyValueStoreRepository.Error;
+}
+export interface IKeyValueStoreRepositoryErrors {
+    base: KeyNotFoundError | KeyValueStorageError;
+}
+type RepositoryError = IKeyValueStoreRepositoryErrors[keyof IKeyValueStoreRepositoryErrors];
+export interface IKeyValueStoreRepository {
+    get<T = unknown>(key: string, scope: string): Promise<Result<T, RepositoryError>>;
+    set(key: string, value: any, scope: string): Promise<Result<void, RepositoryError>>;
+    delete(key: string, scope: string): Promise<Result<void, RepositoryError>>;
+}
+export declare const KeyValueStoreRepository: import("@webiny/di").Abstraction<IKeyValueStoreRepository>;
+export declare namespace KeyValueStoreRepository {
+    type Interface = IKeyValueStoreRepository;
+    type Error = RepositoryError;
+}
+export interface IKeyValueStorageOperations {
+    get(key: string, scope: string): Promise<{
+        key: string;
+        value: any;
+    } | null>;
+    set(key: string, value: any, scope: string): Promise<void>;
+    delete(key: string, scope: string): Promise<void>;
+}
+export declare const KeyValueStorageOperations: import("@webiny/di").Abstraction<IKeyValueStorageOperations>;
+export declare namespace KeyValueStorageOperations {
+    type Interface = IKeyValueStorageOperations;
+}
+export {};

package/features/keyValueStore/abstractions.js

@@ -0,0 +1,19 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// GlobalKeyValueStore - Non-tenant-aware service
+
+export const GlobalKeyValueStore = createAbstraction("GlobalKeyValueStore");
+
+// KeyValueStore - Tenant-aware service
+
+export const KeyValueStore = createAbstraction("KeyValueStore");
+
+// Repository
+
+export const KeyValueStoreRepository = createAbstraction("KeyValueStoreRepository");
+
+// Storage Operations
+
+export const KeyValueStorageOperations = createAbstraction("KeyValueStorageOperations");
+
+//# sourceMappingURL=abstractions.js.map

package/features/keyValueStore/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GlobalKeyValueStore","KeyValueStore","KeyValueStoreRepository","KeyValueStorageOperations"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { KeyNotFoundError, KeyValueStorageError } from \"./errors.js\";\n\nexport interface IKeyValueRecord {\n    key: string;\n    value: any;\n}\n\n// GlobalKeyValueStore - Non-tenant-aware service\nexport interface IGlobalKeyValueStoreOptions {\n    scope?: string;\n}\n\nexport interface IGlobalKeyValueStore {\n    get<T = unknown>(\n        key: string,\n        options?: IGlobalKeyValueStoreOptions\n    ): Promise<Result<T, KeyValueStoreRepository.Error>>;\n    set(\n        key: string,\n        value: any,\n        options?: IGlobalKeyValueStoreOptions\n    ): Promise<Result<void, KeyValueStoreRepository.Error>>;\n    delete(\n        key: string,\n        options?: IGlobalKeyValueStoreOptions\n    ): Promise<Result<void, KeyValueStoreRepository.Error>>;\n}\n\nexport const GlobalKeyValueStore = createAbstraction<IGlobalKeyValueStore>(\"GlobalKeyValueStore\");\n\nexport namespace GlobalKeyValueStore {\n    export type Interface = IGlobalKeyValueStore;\n    export type KeyValueRecord = IKeyValueRecord;\n    export type Error = KeyValueStoreRepository.Error;\n}\n\n// KeyValueStore - Tenant-aware service\nexport interface IKeyValueStore {\n    get<T = unknown>(key: string): Promise<Result<T, KeyValueStoreRepository.Error>>;\n    set(key: string, value: any): Promise<Result<void, KeyValueStoreRepository.Error>>;\n    delete(key: string): Promise<Result<void, KeyValueStoreRepository.Error>>;\n}\n\nexport const KeyValueStore = createAbstraction<IKeyValueStore>(\"KeyValueStore\");\n\nexport namespace KeyValueStore {\n    export type Interface = IKeyValueStore;\n    export type KeyValueRecord = IKeyValueRecord;\n    export type Error = KeyValueStoreRepository.Error;\n}\n\n// Repository\n\nexport interface IKeyValueStoreRepositoryErrors {\n    base: KeyNotFoundError | KeyValueStorageError;\n}\n\ntype RepositoryError = IKeyValueStoreRepositoryErrors[keyof IKeyValueStoreRepositoryErrors];\n\nexport interface IKeyValueStoreRepository {\n    get<T = unknown>(key: string, scope: string): Promise<Result<T, RepositoryError>>;\n    set(key: string, value: any, scope: string): Promise<Result<void, RepositoryError>>;\n    delete(key: string, scope: string): Promise<Result<void, RepositoryError>>;\n}\n\nexport const KeyValueStoreRepository =\n    createAbstraction<IKeyValueStoreRepository>(\"KeyValueStoreRepository\");\n\nexport namespace KeyValueStoreRepository {\n    export type Interface = IKeyValueStoreRepository;\n    export type Error = RepositoryError;\n}\n\n// Storage Operations\n\nexport interface IKeyValueStorageOperations {\n    get(key: string, scope: string): Promise<{ key: string; value: any } | null>;\n    set(key: string, value: any, scope: string): Promise<void>;\n    delete(key: string, scope: string): Promise<void>;\n}\n\nexport const KeyValueStorageOperations = createAbstraction<IKeyValueStorageOperations>(\n    \"KeyValueStorageOperations\"\n);\n\nexport namespace KeyValueStorageOperations {\n    export type Interface = IKeyValueStorageOperations;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AASvD;;AAqBA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;;AAQjG;;AAOA,OAAO,MAAME,aAAa,GAAGF,iBAAiB,CAAiB,eAAe,CAAC;;AAQ/E;;AAcA,OAAO,MAAMG,uBAAuB,GAChCH,iBAAiB,CAA2B,yBAAyB,CAAC;;AAO1E;;AAQA,OAAO,MAAMI,yBAAyB,GAAGJ,iBAAiB,CACtD,2BACJ,CAAC","ignoreList":[]}

package/features/keyValueStore/errors.d.ts

@@ -0,0 +1,11 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class KeyNotFoundError extends BaseError<{
+    key: string;
+}> {
+    readonly code: "KeyValueStore/KeyNotFound";
+    constructor(key: string);
+}
+export declare class KeyValueStorageError extends BaseError {
+    readonly code: "KeyValueStore/Persistence";
+    constructor(error: Error);
+}

package/features/keyValueStore/errors.js

@@ -0,0 +1,22 @@
+import { BaseError } from "@webiny/feature/api";
+export class KeyNotFoundError extends BaseError {
+  code = "KeyValueStore/KeyNotFound";
+  constructor(key) {
+    super({
+      message: `Key "${key}" was not found`,
+      data: {
+        key
+      }
+    });
+  }
+}
+export class KeyValueStorageError extends BaseError {
+  code = "KeyValueStore/Persistence";
+  constructor(error) {
+    super({
+      message: error.message
+    });
+  }
+}
+
+//# sourceMappingURL=errors.js.map

package/features/keyValueStore/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","KeyNotFoundError","code","constructor","key","message","data","KeyValueStorageError","error"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class KeyNotFoundError extends BaseError<{ key: string }> {\n    override readonly code = \"KeyValueStore/KeyNotFound\" as const;\n\n    constructor(key: string) {\n        super({\n            message: `Key \"${key}\" was not found`,\n            data: { key }\n        });\n    }\n}\n\nexport class KeyValueStorageError extends BaseError {\n    override readonly code = \"KeyValueStore/Persistence\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: error.message\n        });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAE/C,OAAO,MAAMC,gBAAgB,SAASD,SAAS,CAAkB;EAC3CE,IAAI,GAAG,2BAA2B;EAEpDC,WAAWA,CAACC,GAAW,EAAE;IACrB,KAAK,CAAC;MACFC,OAAO,EAAE,QAAQD,GAAG,iBAAiB;MACrCE,IAAI,EAAE;QAAEF;MAAI;IAChB,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMG,oBAAoB,SAASP,SAAS,CAAC;EAC9BE,IAAI,GAAG,2BAA2B;EAEpDC,WAAWA,CAACK,KAAY,EAAE;IACtB,KAAK,CAAC;MACFH,OAAO,EAAEG,KAAK,CAACH;IACnB,CAAC,CAAC;EACN;AACJ","ignoreList":[]}

package/features/keyValueStore/feature.d.ts

@@ -0,0 +1 @@
+export declare const KeyValueStoreFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<import("./abstractions.js").IKeyValueStorageOperations>;

package/features/keyValueStore/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { GlobalKeyValueStore } from "./GlobalKeyValueStore.js";
+import { KeyValueStore } from "./KeyValueStore.js";
+import { KeyValueStoreRepository } from "./KeyValueStoreRepository.js";
+import { KeyValueStorageOperations } from "./abstractions.js";
+export const KeyValueStoreFeature = createFeature({
+  name: "KeyValueStore",
+  register(container, storageOperations) {
+    // Register legacy storage operations
+    container.registerInstance(KeyValueStorageOperations, storageOperations);
+    container.register(KeyValueStoreRepository).inSingletonScope();
+    container.register(GlobalKeyValueStore);
+    container.register(KeyValueStore);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/keyValueStore/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GlobalKeyValueStore","KeyValueStore","KeyValueStoreRepository","KeyValueStorageOperations","KeyValueStoreFeature","name","register","container","storageOperations","registerInstance","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GlobalKeyValueStore } from \"./GlobalKeyValueStore.js\";\nimport { KeyValueStore } from \"./KeyValueStore.js\";\nimport { KeyValueStoreRepository } from \"./KeyValueStoreRepository.js\";\nimport { KeyValueStorageOperations } from \"./abstractions.js\";\n\nexport const KeyValueStoreFeature = createFeature({\n    name: \"KeyValueStore\",\n    register(container, storageOperations: KeyValueStorageOperations.Interface) {\n        // Register legacy storage operations\n        container.registerInstance(KeyValueStorageOperations, storageOperations);\n\n        container.register(KeyValueStoreRepository).inSingletonScope();\n        container.register(GlobalKeyValueStore);\n        container.register(KeyValueStore);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,mBAAmB;AAC5B,SAASC,aAAa;AACtB,SAASC,uBAAuB;AAChC,SAASC,yBAAyB;AAElC,OAAO,MAAMC,oBAAoB,GAAGL,aAAa,CAAC;EAC9CM,IAAI,EAAE,eAAe;EACrBC,QAAQA,CAACC,SAAS,EAAEC,iBAAsD,EAAE;IACxE;IACAD,SAAS,CAACE,gBAAgB,CAACN,yBAAyB,EAAEK,iBAAiB,CAAC;IAExED,SAAS,CAACD,QAAQ,CAACJ,uBAAuB,CAAC,CAACQ,gBAAgB,CAAC,CAAC;IAC9DH,SAAS,CAACD,QAAQ,CAACN,mBAAmB,CAAC;IACvCO,SAAS,CAACD,QAAQ,CAACL,aAAa,CAAC;EACrC;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/keyValueStore/index.d.ts

@@ -0,0 +1,2 @@
+export { GlobalKeyValueStore, KeyValueStore, KeyValueStoreRepository, KeyValueStorageOperations } from "./abstractions.js";
+export { KeyNotFoundError, KeyValueStorageError } from "./errors.js";

package/features/keyValueStore/index.js

@@ -0,0 +1,4 @@
+export { GlobalKeyValueStore, KeyValueStore, KeyValueStoreRepository, KeyValueStorageOperations } from "./abstractions.js";
+export { KeyNotFoundError, KeyValueStorageError } from "./errors.js";
+
+//# sourceMappingURL=index.js.map

package/features/keyValueStore/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GlobalKeyValueStore","KeyValueStore","KeyValueStoreRepository","KeyValueStorageOperations","KeyNotFoundError","KeyValueStorageError"],"sources":["index.ts"],"sourcesContent":["export {\n    GlobalKeyValueStore,\n    KeyValueStore,\n    KeyValueStoreRepository,\n    KeyValueStorageOperations\n} from \"./abstractions.js\";\n\nexport { KeyNotFoundError, KeyValueStorageError } from \"./errors.js\";\n"],"mappings":"AAAA,SACIA,mBAAmB,EACnBC,aAAa,EACbC,uBAAuB,EACvBC,yBAAyB;AAG7B,SAASC,gBAAgB,EAAEC,oBAAoB","ignoreList":[]}

package/features/logger/LoggerService.d.ts

@@ -0,0 +1,14 @@
+import { Logger as LoggerAbstraction } from "./abstractions.js";
+export declare class LoggerImpl implements LoggerAbstraction.Interface {
+    private pinoLogger;
+    constructor();
+    trace(objOrMsg: object | string, ...args: any[]): void;
+    debug(objOrMsg: object | string, ...args: any[]): void;
+    info(objOrMsg: object | string, ...args: any[]): void;
+    warn(objOrMsg: object | string, ...args: any[]): void;
+    error(objOrMsg: object | string, ...args: any[]): void;
+    fatal(objOrMsg: object | string, ...args: any[]): void;
+    log(objOrMsg: object | string, ...args: any[]): void;
+    private getLogLevel;
+}
+export declare const Logger: import("@webiny/di").Implementation<typeof LoggerImpl>;

package/features/logger/LoggerService.js

@@ -0,0 +1,52 @@
+import { createImplementation } from "@webiny/feature/api";
+import { pino } from "pino";
+import { Logger as LoggerAbstraction } from "./abstractions.js";
+
+// TODO: We have `pino-lambda` hardcoded here simply b/c of lack of good infrastructure.
+//       We want `pino-lambda` for AWS Lambda, but its setup step relies on context of the Lambda function. That's
+//       why we also have it hardcoded in `createHandler` function in `handler-aws` package.
+//       Once we have a better infrastructure for handling such cases, we should refactor this.
+import { pinoLambdaDestination, StructuredLogFormatter } from "pino-lambda";
+const DEFAULT_LOG_LEVEL = "info";
+export class LoggerImpl {
+  constructor() {
+    const level = this.getLogLevel();
+    const destination = pinoLambdaDestination({
+      formatter: new StructuredLogFormatter()
+    });
+    this.pinoLogger = pino({
+      level
+    }, destination);
+  }
+  trace(objOrMsg, ...args) {
+    this.pinoLogger.trace(objOrMsg, ...args);
+  }
+  debug(objOrMsg, ...args) {
+    this.pinoLogger.debug(objOrMsg, ...args);
+  }
+  info(objOrMsg, ...args) {
+    this.pinoLogger.info(objOrMsg, ...args);
+  }
+  warn(objOrMsg, ...args) {
+    this.pinoLogger.warn(objOrMsg, ...args);
+  }
+  error(objOrMsg, ...args) {
+    this.pinoLogger.error(objOrMsg, ...args);
+  }
+  fatal(objOrMsg, ...args) {
+    this.pinoLogger.fatal(objOrMsg, ...args);
+  }
+  log(objOrMsg, ...args) {
+    this.pinoLogger.info(objOrMsg, ...args);
+  }
+  getLogLevel() {
+    return process.env.WEBINY_API_LOG_LEVEL || DEFAULT_LOG_LEVEL;
+  }
+}
+export const Logger = createImplementation({
+  abstraction: LoggerAbstraction,
+  implementation: LoggerImpl,
+  dependencies: []
+});
+
+//# sourceMappingURL=LoggerService.js.map

package/features/logger/LoggerService.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","pino","Logger","LoggerAbstraction","pinoLambdaDestination","StructuredLogFormatter","DEFAULT_LOG_LEVEL","LoggerImpl","constructor","level","getLogLevel","destination","formatter","pinoLogger","trace","objOrMsg","args","debug","info","warn","error","fatal","log","process","env","WEBINY_API_LOG_LEVEL","abstraction","implementation","dependencies"],"sources":["LoggerService.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { type Logger as PinoLogger, pino } from \"pino\";\nimport { Logger as LoggerAbstraction } from \"./abstractions.js\";\n\n// TODO: We have `pino-lambda` hardcoded here simply b/c of lack of good infrastructure.\n//       We want `pino-lambda` for AWS Lambda, but its setup step relies on context of the Lambda function. That's\n//       why we also have it hardcoded in `createHandler` function in `handler-aws` package.\n//       Once we have a better infrastructure for handling such cases, we should refactor this.\nimport { pinoLambdaDestination, StructuredLogFormatter } from \"pino-lambda\";\n\nconst DEFAULT_LOG_LEVEL = \"info\";\n\nexport class LoggerImpl implements LoggerAbstraction.Interface {\n    private pinoLogger: PinoLogger;\n\n    constructor() {\n        const level = this.getLogLevel();\n        const destination = pinoLambdaDestination({\n            formatter: new StructuredLogFormatter()\n        });\n        this.pinoLogger = pino({ level }, destination);\n    }\n\n    trace(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.trace(objOrMsg, ...args);\n    }\n\n    debug(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.debug(objOrMsg, ...args);\n    }\n\n    info(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.info(objOrMsg, ...args);\n    }\n\n    warn(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.warn(objOrMsg, ...args);\n    }\n\n    error(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.error(objOrMsg, ...args);\n    }\n\n    fatal(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.fatal(objOrMsg, ...args);\n    }\n\n    log(objOrMsg: object | string, ...args: any[]) {\n        this.pinoLogger.info(objOrMsg, ...args);\n    }\n\n    private getLogLevel() {\n        return process.env.WEBINY_API_LOG_LEVEL || DEFAULT_LOG_LEVEL;\n    }\n}\n\nexport const Logger = createImplementation({\n    abstraction: LoggerAbstraction,\n    implementation: LoggerImpl,\n    dependencies: []\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAAoCC,IAAI,QAAQ,MAAM;AACtD,SAASC,MAAM,IAAIC,iBAAiB;;AAEpC;AACA;AACA;AACA;AACA,SAASC,qBAAqB,EAAEC,sBAAsB,QAAQ,aAAa;AAE3E,MAAMC,iBAAiB,GAAG,MAAM;AAEhC,OAAO,MAAMC,UAAU,CAAwC;EAG3DC,WAAWA,CAAA,EAAG;IACV,MAAMC,KAAK,GAAG,IAAI,CAACC,WAAW,CAAC,CAAC;IAChC,MAAMC,WAAW,GAAGP,qBAAqB,CAAC;MACtCQ,SAAS,EAAE,IAAIP,sBAAsB,CAAC;IAC1C,CAAC,CAAC;IACF,IAAI,CAACQ,UAAU,GAAGZ,IAAI,CAAC;MAAEQ;IAAM,CAAC,EAAEE,WAAW,CAAC;EAClD;EAEAG,KAAKA,CAACC,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC7C,IAAI,CAACH,UAAU,CAACC,KAAK,CAACC,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC5C;EAEAC,KAAKA,CAACF,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC7C,IAAI,CAACH,UAAU,CAACI,KAAK,CAACF,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC5C;EAEAE,IAAIA,CAACH,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC5C,IAAI,CAACH,UAAU,CAACK,IAAI,CAACH,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC3C;EAEAG,IAAIA,CAACJ,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC5C,IAAI,CAACH,UAAU,CAACM,IAAI,CAACJ,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC3C;EAEAI,KAAKA,CAACL,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC7C,IAAI,CAACH,UAAU,CAACO,KAAK,CAACL,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC5C;EAEAK,KAAKA,CAACN,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC7C,IAAI,CAACH,UAAU,CAACQ,KAAK,CAACN,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC5C;EAEAM,GAAGA,CAACP,QAAyB,EAAE,GAAGC,IAAW,EAAE;IAC3C,IAAI,CAACH,UAAU,CAACK,IAAI,CAACH,QAAQ,EAAE,GAAGC,IAAI,CAAC;EAC3C;EAEQN,WAAWA,CAAA,EAAG;IAClB,OAAOa,OAAO,CAACC,GAAG,CAACC,oBAAoB,IAAInB,iBAAiB;EAChE;AACJ;AAEA,OAAO,MAAMJ,MAAM,GAAGF,oBAAoB,CAAC;EACvC0B,WAAW,EAAEvB,iBAAiB;EAC9BwB,cAAc,EAAEpB,UAAU;EAC1BqB,YAAY,EAAE;AAClB,CAAC,CAAC","ignoreList":[]}

package/features/logger/abstractions.d.ts

@@ -0,0 +1,13 @@
+export interface ILogger {
+    trace(objOrMsg: object | string, ...args: any[]): void;
+    debug(objOrMsg: object | string, ...args: any[]): void;
+    info(objOrMsg: object | string, ...args: any[]): void;
+    warn(objOrMsg: object | string, ...args: any[]): void;
+    error(objOrMsg: object | string, ...args: any[]): void;
+    fatal(objOrMsg: object | string, ...args: any[]): void;
+    log(objOrMsg: object | string, ...args: any[]): void;
+}
+export declare const Logger: import("@webiny/di").Abstraction<ILogger>;
+export declare namespace Logger {
+    type Interface = ILogger;
+}

package/features/logger/abstractions.js

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

package/features/logger/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","Logger"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface ILogger {\n    // Basic logging levels\n    trace(objOrMsg: object | string, ...args: any[]): void;\n    debug(objOrMsg: object | string, ...args: any[]): void;\n    info(objOrMsg: object | string, ...args: any[]): void;\n    warn(objOrMsg: object | string, ...args: any[]): void;\n    error(objOrMsg: object | string, ...args: any[]): void;\n    fatal(objOrMsg: object | string, ...args: any[]): void;\n\n    // Generic log (defaults to 'info')\n    log(objOrMsg: object | string, ...args: any[]): void;\n}\n\nexport const Logger = createAbstraction<ILogger>(\"Logger\");\n\nexport namespace Logger {\n    export type Interface = ILogger;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAevD,OAAO,MAAMC,MAAM,GAAGD,iBAAiB,CAAU,QAAQ,CAAC","ignoreList":[]}

package/features/logger/feature.d.ts

@@ -0,0 +1 @@
+export declare const LoggerFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;