unconventional 0.0.1 → 0.0.3

package/dist/core/base.options.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="@cloudflare/workers-types" />
+import { ConflictResolution } from "unconventional-pg-queries";
+import { Env } from "../types/api.types";
+import BaseModel from "./base.model";
+export interface PageConfig {
+    limit?: number;
+    cursor?: string;
+    sort?: string;
+}
+export interface FilterConfig {
+    filter?: string;
+    expand?: string;
+}
+interface DownloadResponse {
+    filename: string;
+    buffer: ArrayBufferLike;
+}
+export interface UpsertConfig<M extends typeof BaseModel> {
+    constraint?: Array<keyof InstanceType<M>>;
+    action?: ConflictResolution;
+}
+export interface ServiceConfig<M extends typeof BaseModel> {
+    cache?: KVNamespace;
+    cacheTTL?: number;
+    upsertConfig?: UpsertConfig<M>;
+}
+export interface ControllerOptions {
+    cache?: boolean;
+    cacheTTL?: number;
+}
+export type PI<T extends abstract new (...args: any[]) => any> = Partial<InstanceType<T>>;
+export type I<T extends abstract new (...args: any[]) => any> = InstanceType<T>;
+export interface ControllerMethodOptions<M extends typeof BaseModel, V extends Env, U extends PI<M> | PI<M>[] = PI<M>, W extends I<M> | I<M>[] = I<M>> {
+    before?: BodyProcessor<M, V, U>;
+    after?: ResponseProcessor<M, V, U, W>;
+    cache?: boolean;
+    cacheTTL?: number;
+    limitOverride?: boolean;
+    upsertContraint?: Array<keyof InstanceType<M>>;
+}
+export interface DownloadMethodOptions<M extends typeof BaseModel, V extends Env, U extends PI<M> | PI<M>[] = any, W extends I<M> | I<M>[] = any> {
+    download?: DownloadProcessor<M, V, U, W>;
+}
+export interface RequestContext<M extends typeof BaseModel, V extends Env, U extends PI<M> | PI<M>[] = PI<M>> {
+    headers: Headers;
+    waitUntil: (promise: Promise<unknown>) => void;
+    body: U;
+    params: Record<string, string>;
+    queries: Record<string, string | string[]>;
+    env: V['Bindings'];
+    get: <Key extends keyof V['Variables']>(key: Key) => V['Variables'][Key];
+}
+export type BodyProcessor<M extends typeof BaseModel, V extends Env, U extends PI<M> | PI<M>[] = PI<M>> = (requestContext: RequestContext<M, V, U>) => Promise<void>;
+export type ResponseProcessor<M extends typeof BaseModel, V extends Env = Env, U extends PI<M> | PI<M>[] = PI<M>, W extends I<M> | I<M>[] = I<M>> = (requestContext: RequestContext<M, V, U>, response: W) => Promise<void>;
+export type DownloadProcessor<M extends typeof BaseModel, V extends Env = Env, U extends PI<M> | PI<M>[] = any, W = any> = (requestContext: RequestContext<M, V, U>, response: W) => Promise<DownloadResponse>;
+export {};

package/dist/core/base.options.js

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

package/dist/core/base.service.d.ts

@@ -0,0 +1,15 @@
+import BaseModel from "./base.model";
+import { FilterConfig, PageConfig, ServiceConfig } from "./base.options";
+export default class BaseService<M extends typeof BaseModel> {
+    private model;
+    constructor(model: M);
+    static for<M extends typeof BaseModel>(model: M): BaseService<M>;
+    create(data: Partial<InstanceType<M>>, config?: ServiceConfig<M>): Promise<InstanceType<M>>;
+    createMany(data: Partial<InstanceType<M>>[], config?: ServiceConfig<M>): Promise<InstanceType<M>[]>;
+    get(identifier: string | number, config?: FilterConfig & ServiceConfig<M>): Promise<InstanceType<M>>;
+    getAll(config?: PageConfig & FilterConfig & ServiceConfig<M>): Promise<Array<InstanceType<M>>>;
+    update(identifier: string, data: Partial<InstanceType<M>>, config?: ServiceConfig<M>): Promise<InstanceType<M>>;
+    updateMany(data: Partial<InstanceType<M>>[], config?: ServiceConfig<M>): Promise<InstanceType<M>[]>;
+    delete(identifier: string, config?: ServiceConfig<M>): Promise<InstanceType<M>>;
+    deleteMany(config?: FilterConfig & ServiceConfig<M>): Promise<InstanceType<M>[]>;
+}

package/dist/core/base.service.js

@@ -0,0 +1,122 @@
+import { SqlWhereOperator } from "unconventional-pg-queries";
+import { APIError } from "./api-error";
+import BaseCache from "./base.cache";
+import { buildFilter } from "../utils/db.utils";
+export default class BaseService {
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    static for(model) {
+        return new this(model);
+    }
+    async create(data, config) {
+        const response = await this.model.create(data, config?.upsertConfig);
+        if (!response) {
+            throw APIError.errResourceCreationFailed(`Failed to create ${this.model.name}`);
+        }
+        else if (config?.cache) {
+            await BaseCache.clearPage(config.cache, this.model);
+            await BaseCache.setModel(config.cache, response, undefined, config.cacheTTL);
+        }
+        return response;
+    }
+    async createMany(data, config) {
+        const response = await this.model.createMany(data, config?.upsertConfig);
+        if (!response) {
+            throw APIError.errResourceCreationFailed(`Failed to create ${this.model.name}s`);
+        }
+        else if (config?.cache) {
+            const cache = config.cache;
+            await BaseCache.clearPage(cache, this.model);
+            await Promise.all(response.map(item => BaseCache.setModel(cache, item, undefined, config.cacheTTL)));
+        }
+        return response;
+    }
+    async get(identifier, config) {
+        const { cache, cacheTTL, ...modifiers } = config || {};
+        let entity = null;
+        if (cache) {
+            entity = await BaseCache.getModel(cache, this.model, identifier, modifiers);
+        }
+        if (!entity) {
+            if (!isNaN(+identifier)) {
+                entity = await this.model.findById(identifier, modifiers);
+            }
+            else {
+                const keyFilter = buildFilter(this.model.keyField, SqlWhereOperator.Eq, identifier);
+                const filter = modifiers.filter ? `${modifiers.filter} AND ${keyFilter}` : keyFilter;
+                entity = await this.model.findOne({ ...modifiers, filter });
+            }
+            if (!entity)
+                throw APIError.errNotFound(`No ${this.model.name} found with id ${identifier}`);
+            if (cache) {
+                await BaseCache.setModel(cache, entity, modifiers, cacheTTL);
+            }
+        }
+        return entity;
+    }
+    async getAll(config) {
+        const { cache, cacheTTL, ...modifiers } = config || {};
+        let page = null;
+        if (cache) {
+            page = await BaseCache.getPage(cache, this.model, modifiers);
+        }
+        if (!page) {
+            const limit = modifiers.limit || 12;
+            page = await this.model.findMany({ limit, ...modifiers });
+            if (cache) {
+                await BaseCache.setPage(cache, page, modifiers, cacheTTL);
+            }
+        }
+        return page;
+    }
+    async update(identifier, data, config) {
+        const response = await this.model.update(identifier, data);
+        if (!response) {
+            throw APIError.errNotFound(`No ${this.model.name} found with id ${identifier}`);
+        }
+        else if (config?.cache) {
+            await BaseCache.clearModel(config.cache, response);
+            await BaseCache.setModel(config.cache, response, undefined, config.cacheTTL);
+        }
+        return response;
+    }
+    async updateMany(data, config) {
+        const response = await this.model.updateMany(data);
+        if (!response) {
+            throw APIError.errResourceUpdateFailed(`Failed to update ${this.model.name}s`);
+        }
+        else if (config?.cache) {
+            const cache = config.cache;
+            await Promise.all(response.map(item => BaseCache.clearModel(cache, item)));
+            await Promise.all(response.map(item => BaseCache.setModel(cache, item, undefined, config.cacheTTL)));
+        }
+        return response;
+    }
+    async delete(identifier, config) {
+        const response = await this.model.delete(identifier);
+        if (!response) {
+            throw APIError.errNotFound(`No ${this.model.name} found with id ${identifier}`);
+        }
+        else if (config?.cache) {
+            await BaseCache.clearModel(config.cache, response);
+            await BaseCache.clearPage(config.cache, this.model);
+        }
+        return response;
+    }
+    async deleteMany(config) {
+        if (!config?.filter)
+            throw APIError.errBadRequest("No filter provided");
+        const response = await this.model.deleteMany(config);
+        if (!response) {
+            throw APIError.errResourceDeletionFailed(`Failed to delete ${this.model.name}s`);
+        }
+        else if (config?.cache) {
+            const cache = config.cache;
+            await BaseCache.clearPage(config.cache, this.model);
+            await Promise.all(response.map(item => BaseCache.clearModel(cache, item)));
+        }
+        return response;
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './abstractbase.controller';
+export * from './api-error';
+export * from './base.cache';
+export * from './base.model';
+export * from './base.options';
+export * from './base.service';

package/dist/core/index.js

@@ -0,0 +1,6 @@
+export * from './abstractbase.controller';
+export * from './api-error';
+export * from './base.cache';
+export * from './base.model';
+export * from './base.options';
+export * from './base.service';

package/dist/core/pg.driver.d.ts

@@ -0,0 +1,2 @@
+import { DBFactory } from "../types";
+export declare const PGFactory: DBFactory;

package/dist/core/pg.driver.js

@@ -0,0 +1,21 @@
+async function PGFn(binding, endpoint, query) {
+    const response = await binding.fetch(new Request(`http://worker/${endpoint}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(query)
+    }));
+    if (!response.ok)
+        return null;
+    const body = await response.json();
+    return body;
+}
+export const PGFactory = (ctx) => {
+    return {
+        fetch: async (query) => {
+            return await PGFn(ctx.env.DB_PROXY, 'query', query);
+        },
+        raw: async (query) => {
+            return await PGFn(ctx.env.DB_PROXY, 'text', { text: query });
+        }
+    };
+};

package/dist/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './index.decorator';
+export * from './prop.decorator';
+export * from './timestamp.decorator';
+export * from './utils';

package/dist/decorators/index.decorator.d.ts

@@ -0,0 +1,4 @@
+import BaseModel from '../core/base.model';
+import { IndexDefinition, IndexOptions, TypedClassDecorator } from '../types/decorator.types';
+export declare function index<T extends typeof BaseModel>(fields: IndexDefinition<InstanceType<T>>, options?: IndexOptions): TypedClassDecorator<T>;
+export { index as Index };

package/dist/decorators/index.decorator.js

@@ -0,0 +1,6 @@
+export function index(fields, options) {
+    return (target) => {
+        target.schema.indexes.push({ definition: fields, options });
+    };
+}
+export { index as Index };

package/dist/decorators/index.js

@@ -0,0 +1,4 @@
+export * from './index.decorator';
+export * from './prop.decorator';
+export * from './timestamp.decorator';
+export * from './utils';

package/dist/decorators/prop.decorator.d.ts

@@ -0,0 +1,4 @@
+import BaseModel from '../core/base.model';
+import type { PropOptions } from '../types/decorator.types';
+declare function prop<Target = any, Source extends typeof BaseModel = any, Pivot extends typeof BaseModel = any>(options?: PropOptions<Target, Source, Pivot>): PropertyDecorator;
+export { prop as Prop, prop };

package/dist/decorators/prop.decorator.js

@@ -0,0 +1,13 @@
+function prop(options) {
+    return (target, key) => {
+        const parent = Object.getPrototypeOf(target.constructor);
+        const child = target.constructor;
+        if (child.schema === parent.schema) {
+            child.schema = parent.schema
+                ? { indexes: [...parent.schema.indexes], props: { ...parent.schema.props }, timestamped: parent.schema.timestamped }
+                : { indexes: [], props: {} };
+        }
+        child.schema.props[key] = options || {};
+    };
+}
+export { prop as Prop, prop };

package/dist/decorators/timestamp.decorator.d.ts

@@ -0,0 +1,4 @@
+import { TimeStamped } from '../core/base.model';
+import { TypedClassDecorator } from '../types/decorator.types';
+export declare function timestamp<T extends typeof TimeStamped>(): TypedClassDecorator<T>;
+export { timestamp as Timestamp };

package/dist/decorators/timestamp.decorator.js

@@ -0,0 +1,6 @@
+export function timestamp() {
+    return (target) => {
+        target.schema.timestamped = true;
+    };
+}
+export { timestamp as Timestamp };

package/dist/decorators/utils.d.ts

@@ -0,0 +1 @@
+export declare function getName(target: any): any;

package/dist/decorators/utils.js

@@ -0,0 +1,3 @@
+export function getName(target) {
+    return target.constructor?.name === 'Function' ? target.name : target.constructor.name;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './core';
+export * from './decorators';
+export * from './types';
+export * from './utils';
+export * from './server';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './core';
+export * from './decorators';
+export * from './types';
+export * from './utils';
+export * from './server';

package/dist/server.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="@cloudflare/workers-types" />
+import { Hono } from "hono";
+import type { Env } from "./types/api.types";
+import type { ServerConfig } from "./types/server.types";
+export declare class BackendServer {
+    private _app;
+    configured: boolean;
+    constructor(config?: ServerConfig);
+    get app(): Hono<Env, any, any>;
+    configure(config: ServerConfig): this;
+    start(): (eventContext: import("hono/cloudflare-pages").EventContext<{}, any, {}>) => Response | Promise<Response>;
+}

package/dist/server.js

@@ -0,0 +1,32 @@
+import { Hono } from "hono";
+import { handle } from "hono/cloudflare-pages";
+import { bindDatabase, defaultCors, defaultErrorHandler } from "./utils";
+import { cors } from "hono/cors";
+export class BackendServer {
+    _app;
+    configured = false;
+    constructor(config) {
+        this._app = new Hono();
+        if (config)
+            this.configure(config);
+    }
+    get app() {
+        return this._app;
+    }
+    configure(config) {
+        if (this.configured)
+            throw new Error("Cannot reconfigure server");
+        if (config.basePath)
+            this._app = this._app.basePath(config.basePath);
+        this._app.use(bindDatabase(config.getDB));
+        this._app.use(config.cors ? cors(config.cors) : defaultCors);
+        this._app.onError(defaultErrorHandler);
+        if (config.middleware)
+            this._app.use(...config.middleware);
+        this.configured = true;
+        return this;
+    }
+    start() {
+        return handle(this._app);
+    }
+}

package/dist/types/api.types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="@cloudflare/workers-types" />
+import { Handler, Input } from "hono";
+export declare enum Query {
+    Expand = "expand"
+}
+export declare enum CachePrefix {
+    Record = "rec_",
+    Page = "page_"
+}
+export declare const DefaultCacheTTL = 900;
+export declare const MaxCacheTTL = 2147483647;
+export type Bindings = {
+    CACHE: KVNamespace;
+    STORAGE: KVNamespace;
+    DB_PROXY: Fetcher;
+};
+export declare enum BaseEnvKey {
+    ownerId = "ownerId",
+    isPrivileged = "isPrivileged"
+}
+export type Variables = {
+    [BaseEnvKey.ownerId]?: number;
+    [BaseEnvKey.isPrivileged]?: boolean;
+};
+export type Env<V extends object = {}, B extends object = {}> = {
+    Bindings: Bindings & B;
+    Variables: Variables & V;
+};
+export interface BaseHandler<E extends Env = Env, P extends string = any, I extends Input = Input> extends Handler<E, P, I> {
+}

package/dist/types/api.types.js

@@ -0,0 +1,17 @@
+export var Query;
+(function (Query) {
+    Query["Expand"] = "expand";
+})(Query || (Query = {}));
+export var CachePrefix;
+(function (CachePrefix) {
+    CachePrefix["Record"] = "rec_";
+    CachePrefix["Page"] = "page_";
+})(CachePrefix || (CachePrefix = {}));
+export const DefaultCacheTTL = 900;
+export const MaxCacheTTL = 2147483647;
+export var BaseEnvKey;
+(function (BaseEnvKey) {
+    BaseEnvKey["ownerId"] = "ownerId";
+    BaseEnvKey["isPrivileged"] = "isPrivileged";
+})(BaseEnvKey || (BaseEnvKey = {}));
+;

package/dist/types/db.types.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="@cloudflare/workers-types" />
+import { Context } from "hono";
+import { OneOrMany, QueryDefinition } from "unconventional-pg-queries";
+export declare const ValidSqlOperators: string[];
+export declare const NullSqlOperators: string[];
+export declare const ValidSortDirections: string[];
+export declare const andOrPattern: RegExp;
+export declare enum SqlAction {
+    Select = "SELECT",
+    Insert = "INSERT",
+    Update = "UPDATE",
+    Delete = "DELETE"
+}
+export interface DBCall extends QueryDefinition {
+    action: SqlAction;
+    type: OneOrMany;
+}
+export type DBProxy<I extends string | DBCall> = <R extends object>(query: I) => Promise<R | null>;
+export interface DB {
+    fetch: DBProxy<DBCall>;
+    raw: DBProxy<string>;
+}
+export type DBBinding = Fetcher | D1Database | KVNamespace;
+export type DBFactory = (ctx: Context) => DB;

package/dist/types/db.types.js

@@ -0,0 +1,12 @@
+import { SqlDirection, SqlWhereOperator } from "unconventional-pg-queries";
+export const ValidSqlOperators = Object.values(SqlWhereOperator);
+export const NullSqlOperators = [SqlWhereOperator.IsNull, SqlWhereOperator.IsNotNull];
+export const ValidSortDirections = Object.values(SqlDirection);
+export const andOrPattern = /\s(?=AND|OR)/;
+export var SqlAction;
+(function (SqlAction) {
+    SqlAction["Select"] = "SELECT";
+    SqlAction["Insert"] = "INSERT";
+    SqlAction["Update"] = "UPDATE";
+    SqlAction["Delete"] = "DELETE";
+})(SqlAction || (SqlAction = {}));

package/dist/types/decorator.types.d.ts

@@ -0,0 +1,38 @@
+import BaseModel from "../core/base.model";
+export declare type TypedClassDecorator<T> = (target: T) => T | void;
+export type IndexDefinition<T> = {
+    [P in keyof T]?: 1 | -1;
+};
+export interface IndexOptions {
+    unique?: boolean;
+}
+export interface IndexSummary<T = any> {
+    definition: IndexDefinition<T>;
+    options?: IndexOptions;
+}
+export declare enum RelationType {
+    HasOne = 0,
+    HasMany = 1,
+    ManyToMany = 2,
+    BelongsTo = 3
+}
+export interface RelationPivot<T extends typeof BaseModel = any> {
+    model: T;
+    from: keyof InstanceType<T>;
+    to: keyof InstanceType<T>;
+}
+export interface Relation<Target extends typeof BaseModel = any, Source extends typeof BaseModel = any, Pivot extends typeof BaseModel = any> {
+    type: RelationType;
+    model: Target;
+    from: keyof InstanceType<Source>;
+    to: keyof InstanceType<Target>;
+    through?: RelationPivot<Pivot>;
+}
+export interface PropOptions<T = any, S extends typeof BaseModel = any, P extends typeof BaseModel = any> {
+    required?: boolean;
+    unique?: boolean;
+    enum?: any;
+    default?: T | (() => T);
+    relation?: T extends typeof BaseModel ? Relation<T, S, P> : never;
+}
+export type PropSummary<Target = any, Source extends typeof BaseModel = any> = Record<keyof Source, PropOptions<Target, Source>>;

package/dist/types/decorator.types.js

@@ -0,0 +1,7 @@
+export var RelationType;
+(function (RelationType) {
+    RelationType[RelationType["HasOne"] = 0] = "HasOne";
+    RelationType[RelationType["HasMany"] = 1] = "HasMany";
+    RelationType[RelationType["ManyToMany"] = 2] = "ManyToMany";
+    RelationType[RelationType["BelongsTo"] = 3] = "BelongsTo";
+})(RelationType || (RelationType = {}));

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api.types';
+export * from './db.types';
+export * from './decorator.types';
+export * from './server.types';

package/dist/types/index.js

@@ -0,0 +1,4 @@
+export * from './api.types';
+export * from './db.types';
+export * from './decorator.types';
+export * from './server.types';

package/dist/types/server.types.d.ts

@@ -0,0 +1,10 @@
+import { MiddlewareHandler } from "hono";
+import { DBFactory } from "./db.types";
+import { cors } from "hono/cors";
+export interface ServerConfig {
+    name: string;
+    basePath?: string;
+    middleware?: MiddlewareHandler[];
+    cors?: Parameters<typeof cors>[0];
+    getDB: DBFactory;
+}

package/dist/types/server.types.js

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

package/dist/utils/api.utils.d.ts

@@ -0,0 +1,8 @@
+import { AndOr } from "unconventional-pg-queries";
+export declare function parseExpandString(expand: string): string[];
+export declare function splitExpandUnit(input: string): {
+    parent: string;
+    children: string;
+};
+export declare function replaceFilter(filter: string | string[] | undefined, target: string, replacement: string, andOr?: AndOr): string;
+export declare function hasFilter(filter: string | string[] | undefined, target: string): boolean;

package/dist/utils/api.utils.js

@@ -0,0 +1,46 @@
+import { AndOr } from "unconventional-pg-queries";
+import { andOrPattern } from "../types/db.types";
+const defaultTarget = ',';
+const openBracket = '[';
+const closeBracket = ']';
+export function parseExpandString(expand) {
+    const text = expand.trim();
+    if (!text)
+        return [];
+    const result = [];
+    let word = '';
+    let bracketCount = 0;
+    for (const char of text) {
+        if (bracketCount === 0 && char === defaultTarget) {
+            result.push(`${word}`);
+            word = '';
+        }
+        else {
+            word += char;
+            if (char === openBracket)
+                bracketCount++;
+            else if (char === closeBracket)
+                bracketCount--;
+        }
+    }
+    result.push(`${word}`);
+    return result;
+}
+export function splitExpandUnit(input) {
+    const index = input.indexOf(openBracket);
+    if (index === -1)
+        return { parent: input, children: '' };
+    return { parent: input.slice(0, index), children: input.slice(index + 1, -1) };
+}
+export function replaceFilter(filter, target, replacement, andOr = AndOr.And) {
+    if (!filter)
+        return replacement;
+    const otherFilters = filter.split(andOrPattern).flatMap(x => x.includes(target) ? [] : x);
+    otherFilters.push(`${otherFilters.length ? `${andOr} ` : ''}${replacement}`);
+    return otherFilters.join(' ');
+}
+export function hasFilter(filter, target) {
+    if (!filter)
+        return false;
+    return filter.split(andOrPattern).some(x => x.startsWith(target));
+}

package/dist/utils/array.utils.d.ts

@@ -0,0 +1,2 @@
+export declare const equalArrays: <T>(a: T[], b: T[]) => boolean;
+export declare function isEmpty(obj: any): boolean;

package/dist/utils/array.utils.js

@@ -0,0 +1,20 @@
+export const equalArrays = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    const clone = [...b];
+    for (const key of a) {
+        const idx = b.indexOf(key);
+        if (idx > -1)
+            clone.splice(idx, 1);
+        else {
+            break;
+        }
+    }
+    return clone.length === 0;
+};
+export function isEmpty(obj) {
+    for (const key in obj)
+        if (obj[key] !== undefined)
+            return false;
+    return true;
+}

package/dist/utils/cache.utils.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="@cloudflare/workers-types" />
+export declare function getCachedOrFetch<T>(cache: KVNamespace, key: string, fetchFn: () => Promise<T>, ttl?: number): Promise<T>;

package/dist/utils/cache.utils.js

@@ -0,0 +1,14 @@
+import { DefaultCacheTTL } from "../types/api.types";
+export async function getCachedOrFetch(cache, key, fetchFn, ttl = DefaultCacheTTL) {
+    if (cache) {
+        const cachedResponse = await cache.get(key);
+        if (cachedResponse) {
+            return JSON.parse(cachedResponse);
+        }
+    }
+    const response = await fetchFn();
+    if (response && cache) {
+        await cache.put(key, JSON.stringify(response), { expirationTtl: ttl });
+    }
+    return response;
+}

package/dist/utils/crypto.utils.d.ts

@@ -0,0 +1 @@
+export declare function sha256(value: string): Promise<string>;

package/dist/utils/crypto.utils.js

@@ -0,0 +1,9 @@
+export function sha256(value) {
+    var buffer = new TextEncoder().encode(value);
+    return crypto.subtle.digest("SHA-256", buffer).then(hex);
+}
+function hex(buffer) {
+    return [...new Uint8Array(buffer)]
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}