@webiny/api-core 0.0.0-unstable.0d717d18dd

package/features/eventPublisher/index.js

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

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,21 @@
+import { FeatureFlags } from "./abstractions.js";
+import { BuildParams } from "../buildParams/abstractions.js";
+import { FeatureFlags as feature_flags_FeatureFlags } from "@webiny/feature-flags";
+class FeatureFlagsImpl {
+    constructor(buildParams){
+        this.buildParams = buildParams;
+    }
+    get() {
+        const raw = this.buildParams.get("FeatureFlags") ?? {};
+        return feature_flags_FeatureFlags.fromDto(raw);
+    }
+}
+const FeatureFlags_FeatureFlags = FeatureFlags.createImplementation({
+    implementation: FeatureFlagsImpl,
+    dependencies: [
+        BuildParams
+    ]
+});
+export { FeatureFlags_FeatureFlags as FeatureFlags };
+
+//# sourceMappingURL=FeatureFlags.js.map

package/features/featureFlags/FeatureFlags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/featureFlags/FeatureFlags.js","sources":["../../../src/features/featureFlags/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"],"names":["FeatureFlagsImpl","buildParams","raw","FeatureFlagsClass","FeatureFlags","FeatureFlagsAbstraction","BuildParams"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;IAAqC;IAEzD,MAAyB;QACrB,MAAMC,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,CAAmB,mBAAmB,CAAC;QACvE,OAAOC,2BAAAA,OAAyB,CAACD;IACrC;AACJ;AAEO,MAAME,4BAAeC,aAAAA,oBAA4C,CAAC;IACrE,gBAAgBL;IAChB,cAAc;QAACM;KAAY;AAC/B"}

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,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const FeatureFlags = createAbstraction("FeatureFlags");
+export { FeatureFlags };
+
+//# sourceMappingURL=abstractions.js.map

package/features/featureFlags/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/featureFlags/abstractions.js","sources":["../../../src/features/featureFlags/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"],"names":["FeatureFlags","createAbstraction"],"mappings":";AAOO,MAAMA,eAAeC,kBAA4C"}

package/features/featureFlags/feature.d.ts

@@ -0,0 +1,5 @@
+import type { Container } from "@webiny/di";
+export declare const FeatureFlagsFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/featureFlags/feature.js

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

package/features/featureFlags/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/featureFlags/feature.js","sources":["../../../src/features/featureFlags/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"],"names":["FeatureFlagsFeature","createFeature","container","FeatureFlags"],"mappings":";;AAIO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/hashing/ScryptHasher.d.ts

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

package/features/hashing/ScryptHasher.js

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

package/features/hashing/ScryptHasher.js.map

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

package/features/hashing/abstractions.d.ts

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

package/features/hashing/abstractions.js

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

package/features/hashing/abstractions.js.map

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

package/features/hashing/feature.d.ts

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

package/features/hashing/feature.js

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

package/features/hashing/feature.js.map

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

package/features/hashing/index.d.ts

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

package/features/hashing/index.js

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

package/features/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,35 @@
+import { createImplementation } from "@webiny/feature/api";
+import { GlobalKeyValueStore, KeyValueStoreRepository } 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, {
+            expiresAt: options?.expiresAt
+        });
+    }
+    async delete(key, options) {
+        const scope = this.getScope(options);
+        return this.repository.delete(key, scope);
+    }
+}
+const GlobalKeyValueStore_GlobalKeyValueStore = createImplementation({
+    abstraction: GlobalKeyValueStore,
+    implementation: GlobalKeyValueStoreImpl,
+    dependencies: [
+        KeyValueStoreRepository
+    ]
+});
+export { GlobalKeyValueStore_GlobalKeyValueStore as GlobalKeyValueStore };
+
+//# sourceMappingURL=GlobalKeyValueStore.js.map

package/features/keyValueStore/GlobalKeyValueStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/keyValueStore/GlobalKeyValueStore.js","sources":["../../../src/features/keyValueStore/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            expiresAt: options?.expiresAt\n        });\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"],"names":["DEFAULT_SCOPE","GlobalKeyValueStoreImpl","repository","options","key","scope","value","GlobalKeyValueStore","createImplementation","ServiceAbstraction","KeyValueStoreRepository"],"mappings":";;AAQA,MAAMA,gBAAgB;AAEtB,MAAMC;IACF,YAAoBC,UAA6C,CAAE;aAA/CA,UAAU,GAAVA;IAAgD;IAE5D,SAASC,OAAqC,EAAU;QAC5D,OAAOA,SAAS,SAASH;IAC7B;IAEA,MAAM,IACFI,GAAW,EACXD,OAAqC,EACO;QAC5C,MAAME,QAAQ,IAAI,CAAC,QAAQ,CAACF;QAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAIC,KAAKC;IACvC;IAEA,MAAM,IACFD,GAAW,EACXE,KAAU,EACVH,OAAqC,EACU;QAC/C,MAAME,QAAQ,IAAI,CAAC,QAAQ,CAACF;QAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAACC,KAAKE,OAAOD,OAAO;YAC1C,WAAWF,SAAS;QACxB;IACJ;IAEA,MAAM,OACFC,GAAW,EACXD,OAAqC,EACU;QAC/C,MAAME,QAAQ,IAAI,CAAC,QAAQ,CAACF;QAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACC,KAAKC;IACvC;AACJ;AAEO,MAAME,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBR;IAChB,cAAc;QAACS;KAAwB;AAC3C"}

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,36 @@
+import { GlobalKeyValueStore, KeyValueStore } 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
+        });
+    }
+}
+const KeyValueStore_KeyValueStore = KeyValueStore.createImplementation({
+    implementation: KeyValueStoreImpl,
+    dependencies: [
+        TenantContext,
+        GlobalKeyValueStore
+    ]
+});
+export { KeyValueStore_KeyValueStore as KeyValueStore };
+
+//# sourceMappingURL=KeyValueStore.js.map

package/features/keyValueStore/KeyValueStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/keyValueStore/KeyValueStore.js","sources":["../../../src/features/keyValueStore/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"],"names":["KeyValueStoreImpl","tenantContext","globalStore","key","tenant","value","KeyValueStore","ServiceAbstraction","TenantContext","GlobalKeyValueStore"],"mappings":";;AAKA,MAAMA;IACF,YACYC,aAAsC,EACtCC,WAA0C,CACpD;aAFUD,aAAa,GAAbA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,IAAiBC,GAAW,EAAgD;QAC9E,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAID,KAAK;YAAE,OAAOC,OAAO,EAAE;QAAC;IAC3D;IAEA,MAAM,IAAID,GAAW,EAAEE,KAAU,EAAmD;QAChF,MAAMD,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAACD,KAAKE,OAAO;YAAE,OAAOD,OAAO,EAAE;QAAC;IAC/D;IAEA,MAAM,OAAOD,GAAW,EAAmD;QACvE,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAACD,KAAK;YAAE,OAAOC,OAAO,EAAE;QAAC;IAC3D;AACJ;AAEO,MAAME,8BAAgBC,cAAAA,oBAAuC,CAAC;IACjE,gBAAgBP;IAChB,cAAc;QAACQ;QAAeC;KAAoB;AACtD"}

package/features/keyValueStore/KeyValueStoreRepository.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { KeyValueStorageOperations, KeyValueStoreRepository as RepositoryAbstraction, type IKeyValueStoreSetOptions } 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, options?: IKeyValueStoreSetOptions): 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,43 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { KeyValueStorageOperations, KeyValueStoreRepository } from "./abstractions.js";
+import { KeyNotFoundError, KeyValueStorageError } from "./errors.js";
+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, options) {
+        try {
+            await this.storageOperations.set(key, value, scope, options);
+            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));
+        }
+    }
+}
+const KeyValueStoreRepository_KeyValueStoreRepository = createImplementation({
+    abstraction: KeyValueStoreRepository,
+    implementation: KeyValueStoreRepositoryImpl,
+    dependencies: [
+        KeyValueStorageOperations
+    ]
+});
+export { KeyValueStoreRepository_KeyValueStoreRepository as KeyValueStoreRepository };
+
+//# sourceMappingURL=KeyValueStoreRepository.js.map

package/features/keyValueStore/KeyValueStoreRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/keyValueStore/KeyValueStoreRepository.js","sources":["../../../src/features/keyValueStore/KeyValueStoreRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport {\n    KeyValueStorageOperations,\n    KeyValueStoreRepository as RepositoryAbstraction,\n    type IKeyValueStoreSetOptions\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        options?: IKeyValueStoreSetOptions\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        try {\n            await this.storageOperations.set(key, value, scope, options);\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"],"names":["KeyValueStoreRepositoryImpl","storageOperations","key","scope","record","Result","KeyNotFoundError","error","KeyValueStorageError","value","options","KeyValueStoreRepository","createImplementation","RepositoryAbstraction","KeyValueStorageOperations"],"mappings":";;;AAeA,MAAMA;IACF,YAAoBC,iBAAsD,CAAE;aAAxDA,iBAAiB,GAAjBA;IAAyD;IAE7E,MAAM,IACFC,GAAW,EACXC,KAAa,EACkC;QAC/C,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAACF,KAAKC;YAErD,IAAI,CAACC,QACD,OAAOC,OAAO,IAAI,CAAC,IAAIC,iBAAiBJ;YAG5C,OAAOG,OAAO,EAAE,CAACD,OAAO,KAAK;QACjC,EAAE,OAAOG,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIG,qBAAqBD;QAChD;IACJ;IAEA,MAAM,IACFL,GAAW,EACXO,KAAU,EACVN,KAAa,EACbO,OAAkC,EACgB;QAClD,IAAI;YACA,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAACR,KAAKO,OAAON,OAAOO;YACpD,OAAOL,OAAO,EAAE;QACpB,EAAE,OAAOE,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIG,qBAAqBD;QAChD;IACJ;IAEA,MAAM,OAAOL,GAAW,EAAEC,KAAa,EAAsD;QACzF,IAAI;YACA,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAACD,KAAKC;YACzC,OAAOE,OAAO,EAAE;QACpB,EAAE,OAAOE,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIG,qBAAqBD;QAChD;IACJ;AACJ;AAEO,MAAMI,kDAA0BC,qBAAqB;IACxD,aAAaC;IACb,gBAAgBb;IAChB,cAAc;QAACc;KAA0B;AAC7C"}

package/features/keyValueStore/abstractions.d.ts

@@ -0,0 +1,66 @@
+import { Result } from "@webiny/feature/api";
+import { KeyNotFoundError, KeyValueStorageError } from "./errors.js";
+export interface IKeyValueRecord {
+    key: string;
+    value: any;
+}
+export interface IGlobalKeyValueStoreOptions {
+    scope?: string;
+    expiresAt?: Date;
+}
+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>>;
+}
+/** Global (non-tenant-scoped) key-value store. */
+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>>;
+}
+/** Tenant-scoped key-value store. */
+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 IKeyValueStoreSetOptions {
+    expiresAt?: Date;
+}
+export interface IKeyValueStoreRepository {
+    get<T = unknown>(key: string, scope: string): Promise<Result<T, RepositoryError>>;
+    set(key: string, value: any, scope: string, options?: IKeyValueStoreSetOptions): Promise<Result<void, RepositoryError>>;
+    delete(key: string, scope: string): Promise<Result<void, RepositoryError>>;
+}
+/** Persist and retrieve key-value pairs. */
+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, options?: IKeyValueStoreSetOptions): Promise<void>;
+    delete(key: string, scope: string): Promise<void>;
+}
+/** Storage operations for key-value persistence. */
+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,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+const GlobalKeyValueStore = createAbstraction("GlobalKeyValueStore");
+const KeyValueStore = createAbstraction("KeyValueStore");
+const KeyValueStoreRepository = createAbstraction("KeyValueStoreRepository");
+const KeyValueStorageOperations = createAbstraction("KeyValueStorageOperations");
+export { GlobalKeyValueStore, KeyValueStorageOperations, KeyValueStore, KeyValueStoreRepository };
+
+//# sourceMappingURL=abstractions.js.map

package/features/keyValueStore/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/keyValueStore/abstractions.js","sources":["../../../src/features/keyValueStore/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    expiresAt?: Date;\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\n/** Global (non-tenant-scoped) key-value store. */\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\n/** Tenant-scoped key-value store. */\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 IKeyValueStoreSetOptions {\n    expiresAt?: Date;\n}\n\nexport interface IKeyValueStoreRepository {\n    get<T = unknown>(key: string, scope: string): Promise<Result<T, RepositoryError>>;\n    set(\n        key: string,\n        value: any,\n        scope: string,\n        options?: IKeyValueStoreSetOptions\n    ): Promise<Result<void, RepositoryError>>;\n    delete(key: string, scope: string): Promise<Result<void, RepositoryError>>;\n}\n\n/** Persist and retrieve key-value pairs. */\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, options?: IKeyValueStoreSetOptions): Promise<void>;\n    delete(key: string, scope: string): Promise<void>;\n}\n\n/** Storage operations for key-value persistence. */\nexport const KeyValueStorageOperations = createAbstraction<IKeyValueStorageOperations>(\n    \"KeyValueStorageOperations\"\n);\n\nexport namespace KeyValueStorageOperations {\n    export type Interface = IKeyValueStorageOperations;\n}\n"],"names":["GlobalKeyValueStore","createAbstraction","KeyValueStore","KeyValueStoreRepository","KeyValueStorageOperations"],"mappings":";AAgCO,MAAMA,sBAAsBC,kBAAwC;AAgBpE,MAAMC,gBAAgBD,kBAAkC;AAgCxD,MAAME,0BACTF,kBAA4C;AAgBzC,MAAMG,4BAA4BH,kBACrC"}

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,21 @@
+import { BaseError } from "@webiny/feature/api";
+class KeyNotFoundError extends BaseError {
+    constructor(key){
+        super({
+            message: `Key "${key}" was not found`,
+            data: {
+                key
+            }
+        }), this.code = "KeyValueStore/KeyNotFound";
+    }
+}
+class KeyValueStorageError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message
+        }), this.code = "KeyValueStore/Persistence";
+    }
+}
+export { KeyNotFoundError, KeyValueStorageError };
+
+//# sourceMappingURL=errors.js.map

package/features/keyValueStore/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/keyValueStore/errors.js","sources":["../../../src/features/keyValueStore/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"],"names":["KeyNotFoundError","BaseError","key","KeyValueStorageError","error"],"mappings":";AAEO,MAAMA,yBAAyBC;IAGlC,YAAYC,GAAW,CAAE;QACrB,KAAK,CAAC;YACF,SAAS,CAAC,KAAK,EAAEA,IAAI,eAAe,CAAC;YACrC,MAAM;gBAAEA;YAAI;QAChB,SANc,IAAI,GAAG;IAOzB;AACJ;AAEO,MAAMC,6BAA6BF;IAGtC,YAAYG,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAASA,MAAM,OAAO;QAC1B,SALc,IAAI,GAAG;IAMzB;AACJ"}

package/features/keyValueStore/feature.d.ts

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

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";
+const KeyValueStoreFeature = createFeature({
+    name: "KeyValueStore",
+    register (container, storageOperations) {
+        container.registerInstance(KeyValueStorageOperations, storageOperations);
+        container.register(KeyValueStoreRepository).inSingletonScope();
+        container.register(GlobalKeyValueStore);
+        container.register(KeyValueStore);
+    }
+});
+export { KeyValueStoreFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/keyValueStore/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/keyValueStore/feature.js","sources":["../../../src/features/keyValueStore/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<KeyValueStorageOperations.Interface>({\n    name: \"KeyValueStore\",\n    register(container, storageOperations) {\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"],"names":["KeyValueStoreFeature","createFeature","container","storageOperations","KeyValueStorageOperations","KeyValueStoreRepository","GlobalKeyValueStore","KeyValueStore"],"mappings":";;;;;AAMO,MAAMA,uBAAuBC,cAAmD;IACnF,MAAM;IACN,UAASC,SAAS,EAAEC,iBAAiB;QAEjCD,UAAU,gBAAgB,CAACE,2BAA2BD;QAEtDD,UAAU,QAAQ,CAACG,yBAAyB,gBAAgB;QAC5DH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;IACvB;AACJ"}

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,2 @@
+export { GlobalKeyValueStore, KeyValueStorageOperations, KeyValueStore, KeyValueStoreRepository } from "./abstractions.js";
+export { KeyNotFoundError, KeyValueStorageError } from "./errors.js";