@baeta/cache 0.0.0 → 2.0.0-next.12

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @baeta/cache
+
+## 2.0.0-next.12
+
+### Minor Changes
+
+- [#275](https://github.com/andreisergiu98/baeta/pull/275) [`54f4361`](https://github.com/andreisergiu98/baeta/commit/54f4361c857f2a3d32a29dd898b2be648ac0bb2c) Thanks [@andreisergiu98](https://github.com/andreisergiu98)! - Decouple cache from graphql

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Pampu Andrei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/andreisergiu98/baeta/refs/heads/main/website/static/img/logo-baeta.svg" alt="Baeta Logo" width="150"/>
+</p>
+
+<div align="center">
+  <h1>Baeta</h1>
+  <a href="https://www.npmjs.com/package/@baeta/cli"><img src="https://img.shields.io/npm/v/@baeta/cli.svg?style=flat" /></a>
+   <a href="https://github.com/andreisergiu98/baeta/actions/workflows/checks.yml"><img src="https://img.shields.io/github/actions/workflow/status/andreisergiu98/baeta/checks.yml" /></a>
+  <a href="https://github.com/andreisergiu98/baeta/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" /></a>
+  <a href="https://github.com/andreisergiu98/baeta/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" /></a>
+  <br />
+  <br />
+  <a href="https://baeta.io/docs/getting-started/installation">Getting Started</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://www.baeta.io/">Website</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://baeta.io/docs/intro">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://github.com/andreisergiu98/baeta/tree/main/examples">Examples</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://discord.gg/BHFXHvyj">Discord</a>
+  <br />
+  <hr />
+</div>
+
+# What is Baeta?
+
+Building GraphQL APIs shouldn't be complicated. **Baeta** is a modern, modular, open-source GraphQL framework designed with flexibility in mind. It follows a granular approach where you only add what you need, helping developers focus on what matters most - creating powerful, scalable APIs without the boilerplate.
+
+### Key Features
+
+- **Modular Architecture**: Organize your API into manageable modules
+- **Schema-First Development**: Define your API contract upfront
+- **Type Safety**: Automatic code generation for type-safe development
+- **Middleware & Directives**: Easy integration of custom behaviors
+- **High Performance**: Built for scalability and efficiency
+
+#### And optional extensions and plugins
+
+- **@baeta/extension-auth**: Add powerful scope-based authorization
+- **@baeta/extension-cache**: Implement automatic caching with simple update patterns
+- ... and more!
+
+## Why use Baeta?
+
+Baeta makes it easy to build better GraphQL APIs while staying flexible. Here's how:
+
+**Granular and Progressive:** Start small and add features as you need them. Whether you're building a simple API or a complex system, Baeta scales with your needs.
+
+**Modular architecture:** Baeta's modular design allows you to organize your GraphQL API into smaller, more manageable modules that can be added or removed as needed. This makes it easier to maintain and scale your API over time.
+
+**Schema-first approach:** With Baeta, you define your schema first, and then logic and resolvers. This approach ensures a consistent and well-defined API for your clients and reduces boilerplate code.
+
+## How it Works
+
+#### 1. Define your schema
+
+```graphql
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  age: Int
+}
+
+input UserWhereUnique {
+  id: ID
+  email: String
+}
+
+type Query {
+  user(where: UserWhereUnique!): User!
+  users: [User!]!
+}
+```
+
+#### 2. Implement your resolvers
+
+```typescript
+import { UserModule } from "./typedef.ts";
+
+const { Query } = UserModule;
+
+const userQuery = Query.user.resolve(({ args }) => {
+  return dataSource.user.find(args.where);
+});
+
+const usersQuery = Query.users.resolve(() => {
+  return dataSource.user.findMany();
+});
+
+Query.$fields({
+  user: userQuery,
+  users: usersQuery,
+});
+```
+
+#### 3. Add authorization
+
+```typescript
+import { UserModule } from "./typedef.ts";
+
+const { Query } = UserModule;
+
+const userQuery = Query.user
+  .$auth({
+    $or: {
+      isPublic: true,
+      isLoggedIn: true,
+    },
+  })
+  .resolve(async ({ args }) => {
+    // ...
+  });
+```
+
+#### 4. Add caching
+
+```typescript
+const { Query, Mutation, User } = UserModule;
+
+export const userCache = User.$createCache();
+
+const userQuery = Query.user
+  .$auth({
+    // ...
+  })
+  .$useCache(userCache)
+  .resolve(async ({ args }) => {
+    // ...
+  });
+
+const updateUserMutation = Mutation.updateUser
+  .$use(async (next) => {
+    const user = await next();
+    await userCache.save(user);
+    return user;
+  })
+  .resolve(async ({ args }) => {
+    // ...
+  });
+```
+
+## Compatibility
+
+Baeta is compatible with all GraphQL servers, which makes it easy to integrate with your existing stack. It works seamlessly with popular GraphQL server libraries such as **Graphql Yoga** and **Apollo Server**, as well as other popular tools like **Prisma**, **Drizzle** and **Kysely**.
+
+Baeta's development tools are built for Node.js, but the runtime code is environment-agnostic. This means your Baeta applications can run anywhere JavaScript runs, including:
+
+- Deno
+- Cloudflare Workers
+- AWS Lambda
+- Vercel Edge Functions
+- Bun
+- Node.js
+- Any other JavaScript runtime
+
+## Credits
+
+Baeta was inspired by several amazing projects and people in the GraphQL ecosystem. Check out our [Credits page](https://baeta.io/docs/credits) to learn more about the individuals and projects that influenced Baeta's development.
+
+## License
+
+Baeta is licensed under the [MIT License](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,281 @@
+import DataLoader from "dataloader";
+
+//#region lib/item.d.ts
+/**
+ * Reference type for cached items
+ */
+type ItemRef = string | number | bigint;
+/**
+ * Type constraint for objects that are compatible with default cache ref
+ */
+type RefCompatibleItem = {
+  id: string | number | bigint;
+};
+//#endregion
+//#region lib/query.d.ts
+type QueryIndex = [string, QueryIndexValue];
+type QueryIndexValue = string | number | boolean | null;
+type QueryArgs = Record<string, string | number | boolean | null | Array<string | number | boolean | null> | Record<string, string | number | boolean | null>>;
+interface QueryTag {
+  name: string;
+  revision: number | undefined;
+}
+interface QueryTagWithIndexes extends QueryTag {
+  indexes: QueryIndex[];
+}
+interface QueryTagWithArgs extends QueryTag {
+  args: QueryArgs;
+}
+type QueryArgsIndexes<Args extends QueryArgs, T = Record<string, never>> = { [K in keyof Args]?: Args[K] extends QueryIndexValue ? true : never } & Record<Exclude<keyof T, keyof Args>, never>;
+type IndexedQueryArgs<Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args>> = Pick<Args, keyof Indexes & keyof Args>;
+interface QueryTagWithData<T> extends QueryTagWithArgs {
+  indexes: QueryIndex[];
+  data: null | T | Array<T | null>;
+}
+type QueryHelpersWithoutIndexes = {
+  invalidateAll: () => Promise<void>;
+};
+type QueryHelpersWithIndexes<Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args>> = {
+  invalidateAll: () => Promise<void>;
+  invalidateByArgs: (args: Partial<IndexedQueryArgs<Args, Indexes>> | Partial<IndexedQueryArgs<Args, Indexes>>[]) => Promise<void>;
+};
+type QueryHelpers<Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args>> = Indexes extends Record<string, never> ? QueryHelpersWithoutIndexes : QueryHelpersWithIndexes<Args, Indexes>;
+type QueryResult<Item> = null | Item | Array<null | Item>;
+type ItemFromQueryResult<R> = R extends Array<infer I | null> ? NonNullable<I> : R extends null ? never : R;
+type QueryOptions<Result extends QueryResult<Item>, Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args, Indexes>, Item = ItemFromQueryResult<Result>> = {
+  resolve: (args: Args) => Result | Promise<Result>;
+  indexArgsBy?: Indexes;
+  ttlMs?: number;
+  revision?: number;
+  onUpdate?: (pairs: Array<{
+    next: Item;
+    previous: Item | null;
+  }>, helpers: QueryHelpers<Args, Indexes>) => Promise<void> | void;
+  onInsert?: (items: Item[], helpers: QueryHelpers<Args, Indexes>) => Promise<void> | void;
+  onDelete?: (pairs: Array<{
+    ref: ItemRef;
+    previous: Item | null;
+  }>, helpers: QueryHelpers<Args, Indexes>) => Promise<void> | void;
+};
+type QueryOnUpdateHook<Item> = (pairs: Array<{
+  next: Item;
+  previous: Item | null;
+}>) => Promise<void>;
+type QueryOnInsertHook<Item> = (items: Item[]) => Promise<void>;
+type QueryOnDeleteHook<Item> = (pairs: Array<{
+  ref: ItemRef;
+  previous: Item | null;
+}>) => Promise<void>;
+type QueryHandle<Result extends QueryResult<Item>, Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args, Indexes>, Item = ItemFromQueryResult<Result>> = {
+  call: (args: Args) => Promise<Result>;
+  tag: QueryTag;
+  helpers: QueryHelpersWithIndexes<Args, Indexes>;
+  hooks: {
+    onUpdate?: QueryOnUpdateHook<Item>;
+    onInsert?: QueryOnInsertHook<Item>;
+    onDelete?: QueryOnDeleteHook<Item>;
+  };
+};
+//#endregion
+//#region lib/key.d.ts
+type QueryCacheKey = `${QueryCacheKeyPrefix}:${QueryCacheKeyId}`;
+type QueryCacheIndexKey = `${QueryCacheKeyPrefix}:${QueryCacheIndexKeyId}`;
+type QueryCacheKeyId = `id:${string}`;
+type QueryCacheIndexKeyId = `idx:${string}`;
+type QueryCacheKeyPrefix = `${string}:${string}:query:${string}:${CacheRevisionId}`;
+type ItemCacheKey = `${ItemCacheKeyPrefix}:${ItemCacheKeyId}`;
+type ItemCacheKeyId = `id:${string}`;
+type ItemCacheKeyPrefix = `${string}:${string}:item:${CacheRevisionId}`;
+type CacheRevisionId = `rev_${string}`;
+//#endregion
+//#region lib/client.d.ts
+interface CacheClientArgs<Item> {
+  ttlMs: number;
+  parse: (value: string) => Item | null;
+  serialize: (item: Item) => string;
+}
+interface CacheClientOptions {
+  /**
+   * Revision number for cache invalidation.
+   * Incrementing this number will invalidate all existing cache entries for this store.
+   * @defaultValue "default"
+   */
+  revision?: number;
+  /**
+   * Time-to-live in milliseconds
+   * @defaultValue 3_600_000 (1 hour)
+   */
+  ttlMs?: number;
+  /**
+   *  Optional namespace to prefix all cache keys
+   *  @defaultValue "baeta"
+   */
+  namespace?: string;
+}
+declare abstract class CacheClient {
+  options?: CacheClientOptions;
+  constructor(options?: CacheClientOptions);
+  abstract getPartialItems<Item>(keys: ItemCacheKey[], options: CacheClientArgs<Item>): Promise<Array<Item | null>>;
+  abstract saveItems<Item>(items: Array<[ItemCacheKey, Item]>, options: CacheClientArgs<Item>): Promise<void>;
+  abstract saveItemsWithDiff<Item>(items: Array<[ItemCacheKey, Item]>, options: CacheClientArgs<Item>): Promise<Array<Item | null>>;
+  abstract deleteItems<Item>(keys: ItemCacheKey[], options: CacheClientArgs<Item>): Promise<void>;
+  abstract deleteItemsWithDiff<Item>(keys: ItemCacheKey[], options: CacheClientArgs<Item>): Promise<Array<Item | null>>;
+  abstract getQuery<QueryMetadata>(key: QueryCacheKey, options: CacheClientArgs<QueryMetadata>): Promise<QueryMetadata | null>;
+  abstract saveQuery<QueryMetadata>(key: QueryCacheKey, indexes: QueryCacheIndexKey[], metadata: QueryMetadata, options: CacheClientArgs<QueryMetadata>): Promise<void>;
+  abstract deleteQueries<QueryMetadata>(indexes: QueryCacheIndexKey[], options: CacheClientArgs<QueryMetadata>): Promise<void>;
+}
+//#endregion
+//#region lib/store.d.ts
+interface CacheStoreOptions<Item> {
+  name: string;
+  client: CacheClient;
+  namespace?: string;
+  revision?: string | number;
+  ttlMs?: number;
+  parse: (value: string) => Item;
+  serialize: (item: Item) => string;
+  getRef?: (source: Item) => ItemRef;
+}
+type QueryMetadata = {
+  refs: Array<null | string>;
+  isList: boolean;
+};
+declare class CacheStore<Item> {
+  protected readonly name: string;
+  protected readonly namespace: string;
+  protected readonly revision: string;
+  protected readonly client: CacheClient;
+  protected readonly itemCacheArgs: CacheClientArgs<Item>;
+  protected readonly queryCacheArgs: CacheClientArgs<QueryMetadata>;
+  protected readonly getRef?: (source: Item) => ItemRef;
+  constructor({
+    name,
+    client,
+    namespace,
+    revision,
+    ttlMs,
+    parse,
+    serialize,
+    getRef
+  }: CacheStoreOptions<Item>);
+  protected loadAndParse: (refs: ReadonlyArray<ItemRef>) => Promise<Array<Item | null>>;
+  protected loader: DataLoader<ItemRef, Item | null, ItemRef>;
+  get(ref: ItemRef): Promise<Item | null>;
+  getMany(refs: ItemRef[]): Promise<Item[] | null>;
+  getPartial(refs: ItemRef[]): Promise<Array<Item | null>>;
+  save(item: Item | Item[]): Promise<void>;
+  saveWithDiff(item: Item | Item[]): Promise<Array<Item | null>>;
+  delete(ref: ItemRef | ItemRef[]): Promise<void>;
+  deleteWithDiff(ref: ItemRef | ItemRef[]): Promise<Array<Item | null>>;
+  getQuery(query: QueryTagWithArgs): Promise<{
+    query: unknown;
+  } | null>;
+  saveQuery(query: QueryTagWithData<Item>): Promise<void>;
+  deleteQueries(query: QueryTagWithIndexes): Promise<void>;
+  getRefWithFallback(root: Item): ItemRef;
+  getItemKey(item: Item): ItemCacheKey;
+  getItemKeyByRef(ref: ItemRef): ItemCacheKey;
+  getQueryKey(query: QueryTagWithArgs): QueryCacheKey;
+  getQueryIndexes(query: QueryTagWithIndexes, ensureCatchAll?: boolean): QueryCacheIndexKey[];
+  getQueryKeyPrefix(query: QueryTag): QueryCacheKeyPrefix;
+  getQueryKeyRevision(query: QueryTag): CacheRevisionId;
+}
+//#endregion
+//#region lib/define-query.d.ts
+type QueryFactory<Result extends QueryResult<Item>, Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args, Indexes>, Item = ItemFromQueryResult<Result>> = (store: CacheStore<Item>, name: string) => QueryHandle<Result, Args, Indexes, Item>;
+type QueryMethod<T extends QueryFactory<any, any, any>> = T extends QueryFactory<infer Result, infer Args, any, any> ? (args: Args) => Promise<Result> : never;
+type QueryDefinitionMap<Item> = Record<string, QueryFactory<QueryResult<Item>, any, any, Item>>;
+type QueryMethodMap<Definitions extends QueryDefinitionMap<any>> = { [K in keyof Definitions]: QueryMethod<Definitions[K]> };
+declare function defineQuery<Result extends QueryResult<Item>, Args extends QueryArgs = Record<string, never>, Indexes extends QueryArgsIndexes<Args, Indexes> = Record<string, never>, Item = ItemFromQueryResult<Result>>(options: QueryOptions<Result, Args, Indexes, Item>): QueryFactory<Result, Args, Indexes, Item>;
+//#endregion
+//#region lib/options.d.ts
+/**
+ * Configuration options for cache stores
+ */
+type CacheOptions<Item> = {
+  /**
+   * Unique name for the cache store. Used as a prefix for cache keys to avoid collisions.
+   */
+  name: string;
+  /**
+   * Revision number for cache invalidation.
+   * Incrementing this number will invalidate all existing cache entries for this store.
+   * @defaultValue CacheClient options or "default"
+   */
+  revision?: number;
+  /**
+   * Time-to-live in milliseconds
+   * @defaultValue CacheClient options or 3_600_000 (1 hour)
+   */
+  ttlMs?: number;
+  /**
+   *  Optional namespace to prefix all cache keys
+   *  @defaultValue CacheClient options or "baeta"
+   */
+  namespace?: string;
+  /**
+   * Function to parse stored strings back into source objects.
+   * If it throws an error, the cache will be treated as a miss and the value will be deleted.
+   */
+  parse: (value: string) => Item;
+  /**
+   * Function to serialize source objects into strings for cache storage.
+   */
+  serialize: (value: Item) => string;
+  /**
+   * Hook that gets called with the updated items after an update operation.
+   */
+  onUpdate?: (item: Item[]) => void | Promise<void>;
+  /**
+   * Hook that gets called with the inserted items after an insert operation.
+   */
+  onInsert?: (item: Item[]) => void | Promise<void>;
+  /**
+   * Hook that gets called with the refs of deleted items after a delete operation.
+   */
+  onDelete?: (ref: ItemRef[]) => void | Promise<void>;
+};
+type OptionalGetRef<Item> = {
+  getRef?: (source: Item) => ItemRef;
+};
+type RequiredGetRef<Item> = {
+  getRef: (source: Item) => ItemRef;
+};
+//#endregion
+//#region lib/create-cache.d.ts
+type CacheHooksOptions = {
+  /**
+   * If true, hooks will be awaited. If false, hooks will be fired asynchronously and will not block cache methods.
+   * @defaultValue false
+   */
+  waitForHooks?: boolean;
+};
+type Cache<Item> = {
+  get(ref: ItemRef): Promise<Item | null>;
+  getMany(refs: ItemRef[]): Promise<Item[] | null>;
+  getPartial(refs: ItemRef[]): Promise<Array<Item | null>>;
+  update(item: Item | Item[]): Promise<void>;
+  insert(item: Item | Item[]): Promise<void>;
+  delete(ref: ItemRef | ItemRef[]): Promise<void>;
+};
+type CacheWithQueries<Item, QueryDefinitions extends QueryDefinitionMap<Item>> = {
+  get(ref: ItemRef): Promise<Item | null>;
+  getMany(refs: ItemRef[]): Promise<Item[] | null>;
+  getPartial(refs: ItemRef[]): Promise<Array<Item | null>>;
+  update(item: Item | Item[], options?: CacheHooksOptions): Promise<void>;
+  insert(item: Item | Item[], options?: CacheHooksOptions): Promise<void>;
+  delete(ref: ItemRef | ItemRef[], options?: CacheHooksOptions): Promise<void>;
+  deleteQueries(): Promise<void>;
+  queries: QueryMethodMap<QueryDefinitions>;
+};
+type CreateCacheFactory<Item> = {
+  build: () => Cache<Item>;
+  withQueries: <QueryDefinitions extends QueryDefinitionMap<Item>>(definitions: QueryDefinitions) => {
+    build: () => CacheWithQueries<Item, QueryDefinitions>;
+  };
+};
+declare function createCache<Item extends RefCompatibleItem>(client: CacheClient, options: CacheOptions<Item> & OptionalGetRef<Item>): CreateCacheFactory<Item>;
+declare function createCache<Item>(client: CacheClient, options: CacheOptions<Item> & RequiredGetRef<Item>): CreateCacheFactory<Item>;
+//#endregion
+export { type Cache, CacheClient, type CacheClientArgs, type CacheClientOptions, type CacheHooksOptions, type CacheOptions, type CacheWithQueries, type CreateCacheFactory, type ItemCacheKey, type ItemRef, type OptionalGetRef, type QueryArgs, type QueryArgsIndexes, type QueryCacheIndexKey, type QueryCacheKey, type QueryIndexValue, type QueryOptions, type RequiredGetRef, createCache, defineQuery };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,403 @@
+import { log } from "@baeta/util-log";
+import DataLoader from "dataloader";
+import { encodeBase64 } from "@baeta/util-encoding";
+import { hash } from "ohash";
+//#region lib/client.ts
+var CacheClient = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+};
+//#endregion
+//#region lib/item.ts
+/**
+* Asserts that a given reference is of a valid type (string, number, or bigint) and that it can be safely serialized.
+*/
+function assertValidRefType(ref) {
+	if (typeof ref !== "string" && typeof ref !== "number" && typeof ref !== "bigint") throw new TypeError("Reference must be string, number or bigint. Define getRef function in cache options");
+}
+//#endregion
+//#region lib/key.ts
+function buildCacheRevisionId(revision) {
+	return `rev_${revision}`;
+}
+function buildItemCacheKeyId(id) {
+	return `id:${id}`;
+}
+function buildQueryCacheKeyId(args) {
+	return `id:${hash(args)}`;
+}
+function buildQueryCacheIndexKeyId(index) {
+	if (index == null) return "idx:";
+	const key = index[0];
+	const value = index[1];
+	return `idx:${hash(`${key}=${value === null ? "null" : `_${encodeBase64(value.toString())}`}`)}`;
+}
+function buildQueryCacheIndexKeysIds(indexes) {
+	if (indexes.length === 0) return ["idx:"];
+	return indexes.map((idx) => buildQueryCacheIndexKeyId(idx));
+}
+//#endregion
+//#region lib/utils.ts
+function arrayIsComplete(items) {
+	if (items == null) return false;
+	return items.every((item) => item != null);
+}
+function alignItemsWithRefs(partialRefs, items) {
+	if (partialRefs.length === items.length) return items;
+	let itemIndex = 0;
+	const aligned = [];
+	for (const ref of partialRefs) if (ref == null) aligned.push(null);
+	else aligned.push(items[itemIndex++]);
+	return aligned;
+}
+function toArray(item) {
+	return Array.isArray(item) ? item : [item];
+}
+function zip(array1, array2, fn) {
+	if (array1.length !== array2.length) throw new Error("Arrays must have the same length to be zipped");
+	const result = [];
+	for (let i = 0; i < array1.length; i++) result.push(fn(array1[i], array2[i]));
+	return result;
+}
+//#endregion
+//#region lib/store.ts
+var CacheStore = class {
+	name;
+	namespace;
+	revision;
+	client;
+	itemCacheArgs;
+	queryCacheArgs;
+	getRef;
+	constructor({ name, client, namespace, revision, ttlMs, parse, serialize, getRef }) {
+		this.name = name;
+		this.namespace = namespace ?? "baeta";
+		this.revision = revision?.toString() ?? "default";
+		this.client = client;
+		this.getRef = getRef;
+		this.itemCacheArgs = {
+			ttlMs: ttlMs ?? 36e5,
+			parse: (value) => parseItemSafely(value, parse),
+			serialize: (item) => serialize(item)
+		};
+		this.queryCacheArgs = {
+			ttlMs: ttlMs ?? 36e5,
+			parse: (value) => JSON.parse(value),
+			serialize: (meta) => JSON.stringify(meta)
+		};
+	}
+	loadAndParse = async (refs) => {
+		const keys = refs.map((ref) => this.getItemKeyByRef(ref));
+		return await this.client.getPartialItems(keys, this.itemCacheArgs);
+	};
+	loader = new DataLoader(this.loadAndParse, { cache: false });
+	async get(ref) {
+		return await this.loader.load(ref);
+	}
+	async getMany(refs) {
+		const results = await Promise.all(refs.map((r) => this.get(r)));
+		if (!arrayIsComplete(results)) return null;
+		return results;
+	}
+	async getPartial(refs) {
+		return await Promise.all(refs.map((ref) => this.get(ref)));
+	}
+	async save(item) {
+		const entries = toArray(item).map((item) => [this.getItemKey(item), item]);
+		return this.client.saveItems(entries, this.itemCacheArgs);
+	}
+	async saveWithDiff(item) {
+		const entries = toArray(item).map((item) => [this.getItemKey(item), item]);
+		return await this.client.saveItemsWithDiff(entries, this.itemCacheArgs);
+	}
+	async delete(ref) {
+		const keys = toArray(ref).map((r) => this.getItemKeyByRef(r));
+		await this.client.deleteItems(keys, this.itemCacheArgs);
+	}
+	async deleteWithDiff(ref) {
+		const keys = toArray(ref).map((r) => this.getItemKeyByRef(r));
+		return await this.client.deleteItemsWithDiff(keys, this.itemCacheArgs);
+	}
+	async getQuery(query) {
+		const queryKey = this.getQueryKey(query);
+		const meta = await this.client.getQuery(queryKey, this.queryCacheArgs);
+		if (meta == null) return null;
+		const isList = meta.isList;
+		const nullableRefs = meta.refs;
+		const refs = nullableRefs.filter((ref) => ref != null);
+		const items = await this.getMany(refs);
+		if (items == null) return null;
+		const aligned = alignItemsWithRefs(nullableRefs, items);
+		return { query: isList ? aligned : aligned.at(0) ?? null };
+	}
+	async saveQuery(query) {
+		const data = query.data;
+		const queryKey = this.getQueryKey(query);
+		const queryIndexes = this.getQueryIndexes(query, true);
+		const isList = Array.isArray(data);
+		const nullableItems = isList ? data : [data];
+		const items = nullableItems.filter((item) => item != null);
+		if (items.length > 0) await this.save(items);
+		const metadata = {
+			refs: nullableItems.map((item) => {
+				if (item == null) return null;
+				return this.getRefWithFallback(item).toString();
+			}),
+			isList
+		};
+		return this.client.saveQuery(queryKey, queryIndexes, metadata, this.queryCacheArgs);
+	}
+	deleteQueries(query) {
+		const queryIndexes = this.getQueryIndexes(query);
+		return this.client.deleteQueries(queryIndexes, this.queryCacheArgs);
+	}
+	getRefWithFallback(root) {
+		if (this.getRef) return this.getRef(root);
+		if (root == null) throw new Error("Object is null or undefined, cannot get ref");
+		if (typeof root === "object" && "id" in root) {
+			assertValidRefType(root.id);
+			return root.id.toString();
+		}
+		throw new Error("Object does not have id. Define \"getRef\" function in cache options");
+	}
+	getItemKey(item) {
+		const ref = this.getRefWithFallback(item);
+		return this.getItemKeyByRef(ref);
+	}
+	getItemKeyByRef(ref) {
+		return `${`${this.namespace}:{${this.name}:item:${buildCacheRevisionId(this.revision)}}`}:${buildItemCacheKeyId(ref.toString())}`;
+	}
+	getQueryKey(query) {
+		return `${this.getQueryKeyPrefix(query)}:${buildQueryCacheKeyId(query.args)}`;
+	}
+	getQueryIndexes(query, ensureCatchAll = false) {
+		const prefix = this.getQueryKeyPrefix(query);
+		const keyIndexes = buildQueryCacheIndexKeysIds(query.indexes);
+		if (ensureCatchAll && query.indexes.length > 0) keyIndexes.push(buildQueryCacheIndexKeyId());
+		return keyIndexes.map((keyIndex) => `${prefix}:${keyIndex}`);
+	}
+	getQueryKeyPrefix(query) {
+		return `${this.namespace}:{${this.name}:query:${query.name}:${this.getQueryKeyRevision(query)}}`;
+	}
+	getQueryKeyRevision(query) {
+		return buildCacheRevisionId(`${this.revision}_${query.revision?.toString() ?? "default"}`);
+	}
+};
+function parseItemSafely(value, parseItem) {
+	try {
+		return parseItem(value);
+	} catch (err) {
+		log.warn(err, "Failed to parse item, returning null", { value });
+		return null;
+	}
+}
+//#endregion
+//#region lib/create-cache.ts
+function createCache(client, options) {
+	const storeClient = new CacheStore({
+		client,
+		name: options.name,
+		parse: options.parse,
+		serialize: options.serialize,
+		getRef: options.getRef,
+		ttlMs: options.ttlMs ?? client.options?.ttlMs,
+		namespace: options.namespace ?? client.options?.namespace,
+		revision: options.revision ?? client.options?.revision
+	});
+	return {
+		build: () => createCacheMethods(storeClient, {
+			onUpdateHook: options.onUpdate,
+			onInsertHook: options.onInsert,
+			onDeleteHook: options.onDelete
+		}, {
+			onUpdateHooks: [],
+			onInsertHooks: [],
+			onDeleteHooks: []
+		}),
+		withQueries: (definitions) => {
+			return { build: () => createCacheMethodsWithQueries(storeClient, options, definitions) };
+		}
+	};
+}
+function createCacheMethods(storeClient, itemHooks, queryHooks) {
+	return {
+		get: (ref) => storeClient.get(ref),
+		getMany: (refs) => storeClient.getMany(refs),
+		getPartial: (refs) => storeClient.getPartial(refs),
+		update: async (item, options) => {
+			if (queryHooks.onUpdateHooks.length === 0) {
+				await storeClient.save(item);
+				await fireHook(itemHooks.onUpdateHook, toArray(item), options);
+			} else {
+				const items = toArray(item);
+				const pairs = zip(items, await storeClient.saveWithDiff(items), (next, previous) => ({
+					next,
+					previous
+				}));
+				await Promise.all([fireHook(itemHooks.onUpdateHook, items, options), fireHooks(queryHooks.onUpdateHooks, pairs, options)]);
+			}
+		},
+		insert: async (item, options) => {
+			await storeClient.save(item);
+			if (queryHooks.onInsertHooks.length === 0) await fireHook(itemHooks.onInsertHook, toArray(item), options);
+			else {
+				const items = toArray(item);
+				await Promise.all([fireHook(itemHooks.onInsertHook, items, options), fireHooks(queryHooks.onInsertHooks, items, options)]);
+			}
+		},
+		delete: async (ref, options) => {
+			if (queryHooks.onDeleteHooks.length === 0) {
+				await storeClient.delete(ref);
+				await fireHook(itemHooks.onDeleteHook, toArray(ref), options);
+			} else {
+				const refs = toArray(ref);
+				const previous = await storeClient.deleteWithDiff(refs);
+				await storeClient.delete(refs);
+				const pairs = zip(refs, previous, (ref, previous) => ({
+					ref,
+					previous
+				}));
+				await Promise.all([fireHook(itemHooks.onDeleteHook, refs, options), fireHooks(queryHooks.onDeleteHooks, pairs, options)]);
+			}
+		}
+	};
+}
+function createCacheMethodsWithQueries(storeClient, options, definitions) {
+	const { queries, queryTags, onUpdateHooks, onInsertHooks, onDeleteHooks } = createQueriesAndHooks(definitions, storeClient);
+	return {
+		...createCacheMethods(storeClient, {
+			onUpdateHook: options.onUpdate,
+			onInsertHook: options.onInsert,
+			onDeleteHook: options.onDelete
+		}, {
+			onUpdateHooks,
+			onInsertHooks,
+			onDeleteHooks
+		}),
+		deleteQueries: async () => {
+			const promises = queryTags.map((tag) => storeClient.deleteQueries({
+				...tag,
+				indexes: []
+			}));
+			await Promise.all(promises);
+		},
+		queries
+	};
+}
+function createQueriesAndHooks(definitions, store) {
+	const queries = {};
+	const queryTags = [];
+	const onUpdateHooks = [];
+	const onInsertHooks = [];
+	const onDeleteHooks = [];
+	for (const [queryName, buildQuery] of Object.entries(definitions ?? {})) {
+		const queryHandler = buildQuery(store, queryName);
+		queries[queryName] = queryHandler.call;
+		queryTags.push(queryHandler.tag);
+		if (queryHandler.hooks.onUpdate) onUpdateHooks.push(queryHandler.hooks.onUpdate);
+		if (queryHandler.hooks.onDelete) onDeleteHooks.push(queryHandler.hooks.onDelete);
+		if (queryHandler.hooks.onInsert) onInsertHooks.push(queryHandler.hooks.onInsert);
+	}
+	return {
+		queries,
+		queryTags,
+		onUpdateHooks,
+		onInsertHooks,
+		onDeleteHooks
+	};
+}
+async function fireHook(hook, value, options) {
+	if (hook == null) return;
+	if (options?.waitForHooks) await hook(value);
+	else Promise.resolve().then(() => hook(value)).catch((err) => {
+		log.error(err, "Error in cache hook");
+	});
+}
+async function fireHooks(hooks, value, options) {
+	await Promise.all(hooks.map((hook) => fireHook(hook, value, options)));
+}
+//#endregion
+//#region lib/define-query.ts
+function defineQuery(options) {
+	return (store, name) => {
+		const tag = {
+			name,
+			revision: options.revision
+		};
+		const resolve = async (args) => {
+			const fromCache = await store.getQuery({
+				...tag,
+				args
+			}).catch((err) => {
+				log.error(err, `Failed to get query result for ${name}. Proceeding without caching.`);
+				return null;
+			});
+			if (fromCache != null) return fromCache.query;
+			const data = await options.resolve(args);
+			await store.saveQuery({
+				...tag,
+				args,
+				data,
+				indexes: buildIndexes(args, options.indexArgsBy)
+			}).catch((err) => {
+				log.error(err, `Failed to save query result for ${name}. Proceeding without caching.`);
+			});
+			return data;
+		};
+		const invalidateAll = async () => {
+			await store.deleteQueries({
+				...tag,
+				indexes: []
+			});
+		};
+		const invalidateByArgs = async (args) => {
+			const deletePromises = (Array.isArray(args) ? args : [args]).map((args) => store.deleteQueries({
+				...tag,
+				indexes: buildIndexes(args, options.indexArgsBy)
+			}));
+			await Promise.all(deletePromises);
+		};
+		const helpers = {
+			invalidateAll,
+			invalidateByArgs
+		};
+		const helpersCast = helpers;
+		const { onUpdate, onDelete, onInsert } = options;
+		return {
+			call: resolve,
+			tag,
+			helpers,
+			hooks: {
+				onUpdate: hookWithHelpers(helpersCast, onUpdate),
+				onInsert: hookWithHelpers(helpersCast, onInsert),
+				onDelete: hookWithHelpers(helpersCast, onDelete)
+			}
+		};
+	};
+}
+function hookWithHelpers(helpers, hook) {
+	if (!hook) return;
+	const hookWithHelpers = async (args) => {
+		await hook(args, helpers);
+	};
+	return hookWithHelpers;
+}
+function buildIndexes(args, indexArgsBy) {
+	if (!indexArgsBy) return [];
+	const indexes = [];
+	for (const key in indexArgsBy) {
+		if (!Object.hasOwn(args, key)) continue;
+		const value = args[key];
+		if (value === void 0) continue;
+		if (Array.isArray(value)) continue;
+		if (typeof value === "object" && value !== null) continue;
+		indexes.push([key, value]);
+	}
+	return indexes;
+}
+//#endregion
+export { CacheClient, createCache, defineQuery };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../lib/client.ts","../lib/item.ts","../lib/key.ts","../lib/options.ts","../lib/utils.ts","../lib/store.ts","../lib/create-cache.ts","../lib/define-query.ts"],"sourcesContent":["import type { ItemCacheKey, QueryCacheIndexKey, QueryCacheKey } from './key.ts';\n\nexport interface CacheClientArgs<Item> {\n\tttlMs: number;\n\tparse: (value: string) => Item | null;\n\tserialize: (item: Item) => string;\n}\n\nexport interface CacheClientOptions {\n\t/**\n\t * Revision number for cache invalidation.\n\t * Incrementing this number will invalidate all existing cache entries for this store.\n\t * @defaultValue \"default\"\n\t */\n\trevision?: number;\n\t/**\n\t * Time-to-live in milliseconds\n\t * @defaultValue 3_600_000 (1 hour)\n\t */\n\tttlMs?: number;\n\t/**\n\t *  Optional namespace to prefix all cache keys\n\t *  @defaultValue \"baeta\"\n\t */\n\tnamespace?: string;\n}\n\nexport abstract class CacheClient {\n\toptions?: CacheClientOptions;\n\n\tconstructor(options?: CacheClientOptions) {\n\t\tthis.options = options;\n\t}\n\n\tabstract getPartialItems<Item>(\n\t\tkeys: ItemCacheKey[],\n\t\toptions: CacheClientArgs<Item>,\n\t): Promise<Array<Item | null>>;\n\n\tabstract saveItems<Item>(\n\t\titems: Array<[ItemCacheKey, Item]>,\n\t\toptions: CacheClientArgs<Item>,\n\t): Promise<void>;\n\n\tabstract saveItemsWithDiff<Item>(\n\t\titems: Array<[ItemCacheKey, Item]>,\n\t\toptions: CacheClientArgs<Item>,\n\t): Promise<Array<Item | null>>;\n\n\tabstract deleteItems<Item>(keys: ItemCacheKey[], options: CacheClientArgs<Item>): Promise<void>;\n\n\tabstract deleteItemsWithDiff<Item>(\n\t\tkeys: ItemCacheKey[],\n\t\toptions: CacheClientArgs<Item>,\n\t): Promise<Array<Item | null>>;\n\n\tabstract getQuery<QueryMetadata>(\n\t\tkey: QueryCacheKey,\n\t\toptions: CacheClientArgs<QueryMetadata>,\n\t): Promise<QueryMetadata | null>;\n\n\tabstract saveQuery<QueryMetadata>(\n\t\tkey: QueryCacheKey,\n\t\tindexes: QueryCacheIndexKey[],\n\t\tmetadata: QueryMetadata,\n\t\toptions: CacheClientArgs<QueryMetadata>,\n\t): Promise<void>;\n\n\tabstract deleteQueries<QueryMetadata>(\n\t\tindexes: QueryCacheIndexKey[],\n\t\toptions: CacheClientArgs<QueryMetadata>,\n\t): Promise<void>;\n}\n","/**\n * Reference type for cached items\n */\nexport type ItemRef = string | number | bigint;\n\n/**\n * Type constraint for objects that are compatible with default cache ref\n */\nexport type RefCompatibleItem = { id: string | number | bigint };\n\n/**\n * Asserts that a given reference is of a valid type (string, number, or bigint) and that it can be safely serialized.\n */\nexport function assertValidRefType(ref: unknown): asserts ref is string | number | bigint {\n\tif (typeof ref !== 'string' && typeof ref !== 'number' && typeof ref !== 'bigint') {\n\t\tthrow new TypeError(\n\t\t\t'Reference must be string, number or bigint. Define getRef function in cache options',\n\t\t);\n\t}\n}\n","import { encodeBase64 } from '@baeta/util-encoding';\nimport { hash } from 'ohash';\nimport type { QueryArgs, QueryIndex } from './query.ts';\n\nexport type QueryCacheKey = `${QueryCacheKeyPrefix}:${QueryCacheKeyId}`;\nexport type QueryCacheIndexKey = `${QueryCacheKeyPrefix}:${QueryCacheIndexKeyId}`;\nexport type QueryCacheKeyId = `id:${string}`;\nexport type QueryCacheIndexKeyId = `idx:${string}`;\nexport type QueryCacheKeyPrefix = `${string}:${string}:query:${string}:${CacheRevisionId}`; // $namespace:$storeName:query:$queryName:rev_$value\n\nexport type ItemCacheKey = `${ItemCacheKeyPrefix}:${ItemCacheKeyId}`;\nexport type ItemCacheKeyId = `id:${string}`;\nexport type ItemCacheKeyPrefix = `${string}:${string}:item:${CacheRevisionId}`; // $namespace:$storeName:item:rev_$value\n\nexport type CacheRevisionId = `rev_${string}`;\n\nexport function buildCacheRevisionId(revision: string): CacheRevisionId {\n\treturn `rev_${revision}`;\n}\n\nexport function buildItemCacheKeyId(id: string): ItemCacheKeyId {\n\treturn `id:${id}`;\n}\n\nexport function buildQueryCacheKeyId(args: QueryArgs): QueryCacheKeyId {\n\treturn `id:${hash(args)}`;\n}\n\nexport function buildQueryCacheIndexKeyId(index?: QueryIndex | undefined): QueryCacheIndexKeyId {\n\tif (index == null) {\n\t\treturn 'idx:';\n\t}\n\tconst key = index[0];\n\tconst value = index[1];\n\tconst safeValue = value === null ? 'null' : `_${encodeBase64(value.toString())}`;\n\treturn `idx:${hash(`${key}=${safeValue}`)}`;\n}\n\nexport function buildQueryCacheIndexKeysIds(indexes: QueryIndex[]): QueryCacheIndexKeyId[] {\n\tif (indexes.length === 0) {\n\t\treturn ['idx:'];\n\t}\n\treturn indexes.map((idx) => buildQueryCacheIndexKeyId(idx));\n}\n","import type { ItemRef } from './item.ts';\n\nexport const DEFAULT_REVISION = 'default';\nexport const DEFAULT_NAMESPACE = 'baeta';\nexport const DEFAULT_TTL_MS = 3_600_000; // 1 hour\n\n/**\n * Configuration options for cache stores\n */\nexport type CacheOptions<Item> = {\n\t/**\n\t * Unique name for the cache store. Used as a prefix for cache keys to avoid collisions.\n\t */\n\tname: string;\n\t/**\n\t * Revision number for cache invalidation.\n\t * Incrementing this number will invalidate all existing cache entries for this store.\n\t * @defaultValue CacheClient options or \"default\"\n\t */\n\trevision?: number;\n\t/**\n\t * Time-to-live in milliseconds\n\t * @defaultValue CacheClient options or 3_600_000 (1 hour)\n\t */\n\tttlMs?: number;\n\t/**\n\t *  Optional namespace to prefix all cache keys\n\t *  @defaultValue CacheClient options or \"baeta\"\n\t */\n\tnamespace?: string;\n\t/**\n\t * Function to parse stored strings back into source objects.\n\t * If it throws an error, the cache will be treated as a miss and the value will be deleted.\n\t */\n\tparse: (value: string) => Item;\n\t/**\n\t * Function to serialize source objects into strings for cache storage.\n\t */\n\tserialize: (value: Item) => string;\n\t/**\n\t * Hook that gets called with the updated items after an update operation.\n\t */\n\tonUpdate?: (item: Item[]) => void | Promise<void>;\n\t/**\n\t * Hook that gets called with the inserted items after an insert operation.\n\t */\n\tonInsert?: (item: Item[]) => void | Promise<void>;\n\t/**\n\t * Hook that gets called with the refs of deleted items after a delete operation.\n\t */\n\tonDelete?: (ref: ItemRef[]) => void | Promise<void>;\n};\n\nexport type OptionalGetRef<Item> = {\n\t/*\n\t * Optional function to extract a string reference from source objects.\n\t * Will use \"id\" property by default.\n\t */\n\tgetRef?: (source: Item) => ItemRef;\n};\n\nexport type RequiredGetRef<Item> = {\n\t/*\n\t * Function to extract a string reference from source objects.\n\t */\n\tgetRef: (source: Item) => ItemRef;\n};\n","import type { ItemRef } from './item.ts';\n\nexport function arrayIsComplete<T>(items: Array<T | null> | null): items is T[] {\n\tif (items == null) {\n\t\treturn false;\n\t}\n\treturn items.every((item) => item != null);\n}\n\nexport function alignItemsWithRefs<T>(partialRefs: Array<ItemRef | null>, items: T[]) {\n\tif (partialRefs.length === items.length) {\n\t\treturn items;\n\t}\n\tlet itemIndex = 0;\n\tconst aligned: Array<T | null> = [];\n\tfor (const ref of partialRefs) {\n\t\tif (ref == null) {\n\t\t\taligned.push(null);\n\t\t} else {\n\t\t\taligned.push(items[itemIndex++]);\n\t\t}\n\t}\n\treturn aligned;\n}\n\nexport function fillNullItemsWithFallback<T>(items: Array<T | null>, fallbacks: T[]) {\n\tlet fallbackIndex = 0;\n\tconst completeItems: T[] = [];\n\tfor (const item of items) {\n\t\tif (item != null) {\n\t\t\tcompleteItems.push(item);\n\t\t} else if (fallbackIndex < fallbacks.length) {\n\t\t\tcompleteItems.push(fallbacks[fallbackIndex++]);\n\t\t}\n\t}\n\treturn {\n\t\titems: completeItems,\n\t\tmissing: items.length - completeItems.length,\n\t\textra: fallbacks.length - fallbackIndex,\n\t};\n}\n\nexport function toArray<T>(item: T | T[]): T[] {\n\treturn Array.isArray(item) ? item : [item];\n}\n\nexport function zip<T, U, R>(array1: T[], array2: U[], fn: (a: T, b: U) => R): R[] {\n\tif (array1.length !== array2.length) {\n\t\tthrow new Error('Arrays must have the same length to be zipped');\n\t}\n\tconst result: R[] = [];\n\tfor (let i = 0; i < array1.length; i++) {\n\t\tresult.push(fn(array1[i], array2[i]));\n\t}\n\treturn result;\n}\n","import { log } from '@baeta/util-log';\nimport DataLoader from 'dataloader';\nimport type { CacheClient, CacheClientArgs } from './client.ts';\nimport { assertValidRefType, type ItemRef } from './item.ts';\nimport {\n\tbuildCacheRevisionId,\n\tbuildItemCacheKeyId,\n\tbuildQueryCacheIndexKeyId,\n\tbuildQueryCacheIndexKeysIds,\n\tbuildQueryCacheKeyId,\n\ttype CacheRevisionId,\n\ttype ItemCacheKey,\n\ttype ItemCacheKeyPrefix,\n\ttype QueryCacheIndexKey,\n\ttype QueryCacheKey,\n\ttype QueryCacheKeyPrefix,\n} from './key.ts';\nimport { DEFAULT_NAMESPACE, DEFAULT_REVISION, DEFAULT_TTL_MS } from './options.ts';\nimport type { QueryTag, QueryTagWithArgs, QueryTagWithData, QueryTagWithIndexes } from './query.ts';\nimport { alignItemsWithRefs, arrayIsComplete, toArray } from './utils.ts';\n\nexport interface CacheStoreOptions<Item> {\n\tname: string;\n\tclient: CacheClient;\n\tnamespace?: string;\n\trevision?: string | number;\n\tttlMs?: number;\n\tparse: (value: string) => Item;\n\tserialize: (item: Item) => string;\n\tgetRef?: (source: Item) => ItemRef;\n}\n\ntype QueryMetadata = { refs: Array<null | string>; isList: boolean };\n\nexport class CacheStore<Item> {\n\tprotected readonly name: string;\n\tprotected readonly namespace: string;\n\tprotected readonly revision: string;\n\n\tprotected readonly client: CacheClient;\n\tprotected readonly itemCacheArgs: CacheClientArgs<Item>;\n\tprotected readonly queryCacheArgs: CacheClientArgs<QueryMetadata>;\n\n\tprotected readonly getRef?: (source: Item) => ItemRef;\n\n\tconstructor({\n\t\tname,\n\t\tclient,\n\t\tnamespace,\n\t\trevision,\n\t\tttlMs,\n\t\tparse,\n\t\tserialize,\n\t\tgetRef,\n\t}: CacheStoreOptions<Item>) {\n\t\tthis.name = name;\n\t\tthis.namespace = namespace ?? DEFAULT_NAMESPACE;\n\t\tthis.revision = revision?.toString() ?? DEFAULT_REVISION;\n\t\tthis.client = client;\n\t\tthis.getRef = getRef;\n\t\tthis.itemCacheArgs = {\n\t\t\tttlMs: ttlMs ?? DEFAULT_TTL_MS,\n\t\t\tparse: (value: string) => parseItemSafely(value, parse),\n\t\t\tserialize: (item: Item) => serialize(item),\n\t\t};\n\t\tthis.queryCacheArgs = {\n\t\t\tttlMs: ttlMs ?? DEFAULT_TTL_MS,\n\t\t\tparse: (value: string) => JSON.parse(value) as QueryMetadata,\n\t\t\tserialize: (meta: QueryMetadata) => JSON.stringify(meta),\n\t\t};\n\t}\n\n\tprotected loadAndParse = async (refs: ReadonlyArray<ItemRef>): Promise<Array<Item | null>> => {\n\t\tconst keys = refs.map((ref) => this.getItemKeyByRef(ref));\n\t\treturn await this.client.getPartialItems(keys, this.itemCacheArgs);\n\t};\n\n\tprotected loader = new DataLoader<ItemRef, Item | null>(this.loadAndParse, {\n\t\tcache: false,\n\t});\n\n\tasync get(ref: ItemRef): Promise<Item | null> {\n\t\treturn await this.loader.load(ref);\n\t}\n\n\tasync getMany(refs: ItemRef[]): Promise<Item[] | null> {\n\t\tconst results = await Promise.all(refs.map((r) => this.get(r)));\n\t\tif (!arrayIsComplete(results)) {\n\t\t\treturn null;\n\t\t}\n\t\treturn results;\n\t}\n\n\tasync getPartial(refs: ItemRef[]): Promise<Array<Item | null>> {\n\t\treturn await Promise.all(refs.map((ref) => this.get(ref)));\n\t}\n\n\tasync save(item: Item | Item[]) {\n\t\tconst values = toArray(item);\n\t\tconst entries: Array<[ItemCacheKey, Item]> = values.map((item) => [\n\t\t\tthis.getItemKey(item),\n\t\t\titem,\n\t\t]);\n\t\treturn this.client.saveItems(entries, this.itemCacheArgs);\n\t}\n\n\tasync saveWithDiff(item: Item | Item[]): Promise<Array<Item | null>> {\n\t\tconst values = toArray(item);\n\t\tconst entries: Array<[ItemCacheKey, Item]> = values.map((item) => [\n\t\t\tthis.getItemKey(item),\n\t\t\titem,\n\t\t]);\n\t\treturn await this.client.saveItemsWithDiff(entries, this.itemCacheArgs);\n\t}\n\n\tasync delete(ref: ItemRef | ItemRef[]) {\n\t\tconst refs = toArray(ref);\n\t\tconst keys = refs.map((r) => this.getItemKeyByRef(r));\n\t\tawait this.client.deleteItems(keys, this.itemCacheArgs);\n\t}\n\n\tasync deleteWithDiff(ref: ItemRef | ItemRef[]): Promise<Array<Item | null>> {\n\t\tconst refs = toArray(ref);\n\t\tconst keys = refs.map((r) => this.getItemKeyByRef(r));\n\t\treturn await this.client.deleteItemsWithDiff(keys, this.itemCacheArgs);\n\t}\n\n\tasync getQuery(query: QueryTagWithArgs): Promise<{ query: unknown } | null> {\n\t\tconst queryKey = this.getQueryKey(query);\n\t\tconst meta = await this.client.getQuery(queryKey, this.queryCacheArgs);\n\n\t\tif (meta == null) {\n\t\t\treturn null;\n\t\t}\n\n\t\tconst isList = meta.isList;\n\t\tconst nullableRefs = meta.refs;\n\t\tconst refs = nullableRefs.filter((ref) => ref != null);\n\t\tconst items = await this.getMany(refs);\n\n\t\tif (items == null) {\n\t\t\treturn null;\n\t\t}\n\n\t\tconst aligned = alignItemsWithRefs(nullableRefs, items);\n\t\tconst result = isList ? aligned : (aligned.at(0) ?? null);\n\n\t\treturn { query: result };\n\t}\n\n\tasync saveQuery(query: QueryTagWithData<Item>): Promise<void> {\n\t\tconst data = query.data;\n\t\tconst queryKey = this.getQueryKey(query);\n\t\tconst queryIndexes = this.getQueryIndexes(query, true);\n\n\t\tconst isList = Array.isArray(data);\n\t\tconst nullableItems = isList ? data : [data];\n\t\tconst items = nullableItems.filter((item) => item != null);\n\n\t\tif (items.length > 0) {\n\t\t\tawait this.save(items);\n\t\t}\n\n\t\tconst encodedRefs = nullableItems.map((item) => {\n\t\t\tif (item == null) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\treturn this.getRefWithFallback(item).toString();\n\t\t});\n\n\t\tconst metadata = {\n\t\t\trefs: encodedRefs,\n\t\t\tisList,\n\t\t};\n\n\t\treturn this.client.saveQuery(queryKey, queryIndexes, metadata, this.queryCacheArgs);\n\t}\n\n\tdeleteQueries(query: QueryTagWithIndexes): Promise<void> {\n\t\tconst queryIndexes = this.getQueryIndexes(query);\n\t\treturn this.client.deleteQueries(queryIndexes, this.queryCacheArgs);\n\t}\n\n\tgetRefWithFallback(root: Item): ItemRef {\n\t\tif (this.getRef) {\n\t\t\treturn this.getRef(root);\n\t\t}\n\t\tif (root == null) {\n\t\t\tthrow new Error('Object is null or undefined, cannot get ref');\n\t\t}\n\t\tif (typeof root === 'object' && 'id' in root) {\n\t\t\tassertValidRefType(root.id);\n\t\t\treturn root.id.toString();\n\t\t}\n\t\tthrow new Error('Object does not have id. Define \"getRef\" function in cache options');\n\t}\n\n\tgetItemKey(item: Item): ItemCacheKey {\n\t\tconst ref = this.getRefWithFallback(item);\n\t\treturn this.getItemKeyByRef(ref);\n\t}\n\n\tgetItemKeyByRef(ref: ItemRef): ItemCacheKey {\n\t\tconst prefix: ItemCacheKeyPrefix = `${this.namespace}:{${this.name}:item:${buildCacheRevisionId(this.revision)}}`;\n\t\tconst keyId = buildItemCacheKeyId(ref.toString());\n\t\treturn `${prefix}:${keyId}`;\n\t}\n\n\tgetQueryKey(query: QueryTagWithArgs): QueryCacheKey {\n\t\tconst prefix = this.getQueryKeyPrefix(query);\n\t\treturn `${prefix}:${buildQueryCacheKeyId(query.args)}`;\n\t}\n\n\tgetQueryIndexes(query: QueryTagWithIndexes, ensureCatchAll = false): QueryCacheIndexKey[] {\n\t\tconst prefix = this.getQueryKeyPrefix(query);\n\t\tconst keyIndexes = buildQueryCacheIndexKeysIds(query.indexes);\n\t\tif (ensureCatchAll && query.indexes.length > 0) {\n\t\t\tkeyIndexes.push(buildQueryCacheIndexKeyId());\n\t\t}\n\t\treturn keyIndexes.map((keyIndex) => `${prefix}:${keyIndex}` as const);\n\t}\n\n\tgetQueryKeyPrefix(query: QueryTag): QueryCacheKeyPrefix {\n\t\treturn `${this.namespace}:{${this.name}:query:${query.name}:${this.getQueryKeyRevision(query)}}`;\n\t}\n\n\tgetQueryKeyRevision(query: QueryTag): CacheRevisionId {\n\t\tconst combinedRevision = `${this.revision}_${query.revision?.toString() ?? DEFAULT_REVISION}`;\n\t\treturn buildCacheRevisionId(combinedRevision);\n\t}\n}\n\nfunction parseItemSafely<T>(value: string, parseItem: (value: string) => T): T | null {\n\ttry {\n\t\treturn parseItem(value);\n\t} catch (err) {\n\t\tlog.warn(err, 'Failed to parse item, returning null', {\n\t\t\tvalue,\n\t\t});\n\t\treturn null;\n\t}\n}\n","import { log } from '@baeta/util-log';\nimport type { CacheClient } from './client.ts';\nimport type { QueryDefinitionMap, QueryMethod, QueryMethodMap } from './define-query.ts';\nimport type { ItemRef, RefCompatibleItem } from './item.ts';\nimport type { CacheOptions, OptionalGetRef, RequiredGetRef } from './options.ts';\nimport type { QueryOnDeleteHook, QueryOnInsertHook, QueryOnUpdateHook, QueryTag } from './query.ts';\nimport { CacheStore } from './store.ts';\nimport { toArray, zip } from './utils.ts';\n\nexport type CacheHooksOptions = {\n\t/**\n\t * If true, hooks will be awaited. If false, hooks will be fired asynchronously and will not block cache methods.\n\t * @defaultValue false\n\t */\n\twaitForHooks?: boolean;\n};\n\nexport type Cache<Item> = {\n\tget(ref: ItemRef): Promise<Item | null>;\n\tgetMany(refs: ItemRef[]): Promise<Item[] | null>;\n\tgetPartial(refs: ItemRef[]): Promise<Array<Item | null>>;\n\tupdate(item: Item | Item[]): Promise<void>;\n\tinsert(item: Item | Item[]): Promise<void>;\n\tdelete(ref: ItemRef | ItemRef[]): Promise<void>;\n};\n\nexport type CacheWithQueries<Item, QueryDefinitions extends QueryDefinitionMap<Item>> = {\n\tget(ref: ItemRef): Promise<Item | null>;\n\tgetMany(refs: ItemRef[]): Promise<Item[] | null>;\n\tgetPartial(refs: ItemRef[]): Promise<Array<Item | null>>;\n\tupdate(item: Item | Item[], options?: CacheHooksOptions): Promise<void>;\n\tinsert(item: Item | Item[], options?: CacheHooksOptions): Promise<void>;\n\tdelete(ref: ItemRef | ItemRef[], options?: CacheHooksOptions): Promise<void>;\n\tdeleteQueries(): Promise<void>;\n\tqueries: QueryMethodMap<QueryDefinitions>;\n};\n\nexport type CreateCacheFactory<Item> = {\n\tbuild: () => Cache<Item>;\n\twithQueries: <QueryDefinitions extends QueryDefinitionMap<Item>>(\n\t\tdefinitions: QueryDefinitions,\n\t) => {\n\t\tbuild: () => CacheWithQueries<Item, QueryDefinitions>;\n\t};\n};\n\nexport function createCache<Item extends RefCompatibleItem>(\n\tclient: CacheClient,\n\toptions: CacheOptions<Item> & OptionalGetRef<Item>,\n): CreateCacheFactory<Item>;\nexport function createCache<Item>(\n\tclient: CacheClient,\n\toptions: CacheOptions<Item> & RequiredGetRef<Item>,\n): CreateCacheFactory<Item>;\nexport function createCache<Item>(\n\tclient: CacheClient,\n\toptions: CacheOptions<Item> & OptionalGetRef<Item>,\n): CreateCacheFactory<Item> {\n\tconst storeClient = new CacheStore<Item>({\n\t\tclient,\n\t\tname: options.name,\n\t\tparse: options.parse,\n\t\tserialize: options.serialize,\n\t\tgetRef: options.getRef,\n\t\tttlMs: options.ttlMs ?? client.options?.ttlMs,\n\t\tnamespace: options.namespace ?? client.options?.namespace,\n\t\trevision: options.revision ?? client.options?.revision,\n\t});\n\treturn {\n\t\tbuild: () =>\n\t\t\tcreateCacheMethods(\n\t\t\t\tstoreClient,\n\t\t\t\t{\n\t\t\t\t\tonUpdateHook: options.onUpdate,\n\t\t\t\t\tonInsertHook: options.onInsert,\n\t\t\t\t\tonDeleteHook: options.onDelete,\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tonUpdateHooks: [],\n\t\t\t\t\tonInsertHooks: [],\n\t\t\t\t\tonDeleteHooks: [],\n\t\t\t\t},\n\t\t\t),\n\t\twithQueries: (definitions) => {\n\t\t\treturn {\n\t\t\t\tbuild: () => createCacheMethodsWithQueries(storeClient, options, definitions),\n\t\t\t};\n\t\t},\n\t};\n}\n\nfunction createCacheMethods<Item>(\n\tstoreClient: CacheStore<Item>,\n\titemHooks: {\n\t\tonUpdateHook?: (item: Item[]) => void | Promise<void>;\n\t\tonInsertHook?: (item: Item[]) => void | Promise<void>;\n\t\tonDeleteHook?: (ref: ItemRef[]) => void | Promise<void>;\n\t},\n\tqueryHooks: {\n\t\tonUpdateHooks: Array<QueryOnUpdateHook<Item>>;\n\t\tonInsertHooks: Array<QueryOnInsertHook<Item>>;\n\t\tonDeleteHooks: Array<QueryOnDeleteHook<Item>>;\n\t},\n): Cache<Item> | Omit<CacheWithQueries<Item, any>, 'queries' | 'deleteQueries'> {\n\treturn {\n\t\tget: (ref) => storeClient.get(ref),\n\t\tgetMany: (refs) => storeClient.getMany(refs),\n\t\tgetPartial: (refs) => storeClient.getPartial(refs),\n\t\tupdate: async (item, options) => {\n\t\t\tif (queryHooks.onUpdateHooks.length === 0) {\n\t\t\t\tawait storeClient.save(item);\n\t\t\t\tawait fireHook(itemHooks.onUpdateHook, toArray(item), options);\n\t\t\t} else {\n\t\t\t\tconst items = toArray(item);\n\t\t\t\tconst previous = await storeClient.saveWithDiff(items);\n\t\t\t\tconst pairs = zip(items, previous, (next, previous) => ({ next, previous }));\n\t\t\t\tawait Promise.all([\n\t\t\t\t\tfireHook(itemHooks.onUpdateHook, items, options),\n\t\t\t\t\tfireHooks(queryHooks.onUpdateHooks, pairs, options),\n\t\t\t\t]);\n\t\t\t}\n\t\t},\n\t\tinsert: async (item, options) => {\n\t\t\tawait storeClient.save(item);\n\t\t\tif (queryHooks.onInsertHooks.length === 0) {\n\t\t\t\tawait fireHook(itemHooks.onInsertHook, toArray(item), options);\n\t\t\t} else {\n\t\t\t\tconst items = toArray(item);\n\t\t\t\tawait Promise.all([\n\t\t\t\t\tfireHook(itemHooks.onInsertHook, items, options),\n\t\t\t\t\tfireHooks(queryHooks.onInsertHooks, items, options),\n\t\t\t\t]);\n\t\t\t}\n\t\t},\n\t\tdelete: async (ref, options) => {\n\t\t\tif (queryHooks.onDeleteHooks.length === 0) {\n\t\t\t\tawait storeClient.delete(ref);\n\t\t\t\tawait fireHook(itemHooks.onDeleteHook, toArray(ref), options);\n\t\t\t} else {\n\t\t\t\tconst refs = toArray(ref);\n\t\t\t\tconst previous = await storeClient.deleteWithDiff(refs);\n\t\t\t\tawait storeClient.delete(refs);\n\t\t\t\tconst pairs = zip(refs, previous, (ref, previous) => ({ ref, previous }));\n\t\t\t\tawait Promise.all([\n\t\t\t\t\tfireHook(itemHooks.onDeleteHook, refs, options),\n\t\t\t\t\tfireHooks(queryHooks.onDeleteHooks, pairs, options),\n\t\t\t\t]);\n\t\t\t}\n\t\t},\n\t};\n}\n\nfunction createCacheMethodsWithQueries<Item, QueryDefinitions extends QueryDefinitionMap<Item>>(\n\tstoreClient: CacheStore<Item>,\n\toptions: CacheOptions<Item> & OptionalGetRef<Item>,\n\tdefinitions: QueryDefinitions,\n): CacheWithQueries<Item, QueryDefinitions> {\n\tconst { queries, queryTags, onUpdateHooks, onInsertHooks, onDeleteHooks } = createQueriesAndHooks<\n\t\tItem,\n\t\tQueryDefinitions\n\t>(definitions, storeClient);\n\treturn {\n\t\t...createCacheMethods(\n\t\t\tstoreClient,\n\t\t\t{\n\t\t\t\tonUpdateHook: options.onUpdate,\n\t\t\t\tonInsertHook: options.onInsert,\n\t\t\t\tonDeleteHook: options.onDelete,\n\t\t\t},\n\t\t\t{ onUpdateHooks, onInsertHooks, onDeleteHooks },\n\t\t),\n\t\tdeleteQueries: async () => {\n\t\t\tconst promises = queryTags.map((tag) =>\n\t\t\t\tstoreClient.deleteQueries({\n\t\t\t\t\t...tag,\n\t\t\t\t\tindexes: [],\n\t\t\t\t}),\n\t\t\t);\n\t\t\tawait Promise.all(promises);\n\t\t},\n\t\tqueries,\n\t};\n}\n\nfunction createQueriesAndHooks<Item, QueryDefinitions extends QueryDefinitionMap<Item>>(\n\tdefinitions: QueryDefinitions | undefined,\n\tstore: CacheStore<Item>,\n) {\n\tconst queries: Partial<QueryMethodMap<QueryDefinitions>> = {};\n\tconst queryTags: QueryTag[] = [];\n\tconst onUpdateHooks: Array<QueryOnUpdateHook<Item>> = [];\n\tconst onInsertHooks: Array<QueryOnInsertHook<Item>> = [];\n\tconst onDeleteHooks: Array<QueryOnDeleteHook<Item>> = [];\n\tfor (const [queryName, buildQuery] of Object.entries(definitions ?? {})) {\n\t\tconst queryHandler = buildQuery(store, queryName);\n\t\tqueries[queryName as keyof QueryDefinitions] = queryHandler.call as QueryMethod<\n\t\t\tQueryDefinitions[keyof QueryDefinitions]\n\t\t>;\n\t\tqueryTags.push(queryHandler.tag);\n\t\tif (queryHandler.hooks.onUpdate) {\n\t\t\tonUpdateHooks.push(queryHandler.hooks.onUpdate);\n\t\t}\n\t\tif (queryHandler.hooks.onDelete) {\n\t\t\tonDeleteHooks.push(queryHandler.hooks.onDelete);\n\t\t}\n\t\tif (queryHandler.hooks.onInsert) {\n\t\t\tonInsertHooks.push(queryHandler.hooks.onInsert);\n\t\t}\n\t}\n\treturn {\n\t\tqueries: queries as QueryMethodMap<QueryDefinitions>,\n\t\tqueryTags,\n\t\tonUpdateHooks,\n\t\tonInsertHooks,\n\t\tonDeleteHooks,\n\t};\n}\n\nasync function fireHook<T>(\n\thook: ((v: T) => void | Promise<void>) | undefined,\n\tvalue: T,\n\toptions?: CacheHooksOptions,\n) {\n\tif (hook == null) {\n\t\treturn;\n\t}\n\tif (options?.waitForHooks) {\n\t\tawait hook(value);\n\t} else {\n\t\tPromise.resolve()\n\t\t\t.then(() => hook(value))\n\t\t\t.catch((err) => {\n\t\t\t\tlog.error(err, 'Error in cache hook');\n\t\t\t});\n\t}\n}\n\nasync function fireHooks<T>(\n\thooks: Array<(v: T) => Promise<void>>,\n\tvalue: T,\n\toptions?: CacheHooksOptions,\n) {\n\tawait Promise.all(hooks.map((hook) => fireHook(hook, value, options)));\n}\n","import { log } from '@baeta/util-log';\nimport type {\n\tIndexedQueryArgs,\n\tItemFromQueryResult,\n\tQueryArgs,\n\tQueryArgsIndexes,\n\tQueryHandle,\n\tQueryHelpers,\n\tQueryHelpersWithIndexes,\n\tQueryIndex,\n\tQueryOptions,\n\tQueryResult,\n\tQueryTag,\n} from './query.ts';\nimport type { CacheStore } from './store.ts';\n\nexport type QueryFactory<\n\tResult extends QueryResult<Item>,\n\tArgs extends QueryArgs,\n\tIndexes extends QueryArgsIndexes<Args, Indexes>,\n\tItem = ItemFromQueryResult<Result>,\n> = (store: CacheStore<Item>, name: string) => QueryHandle<Result, Args, Indexes, Item>;\n\nexport type QueryMethod<T extends QueryFactory<any, any, any>> =\n\tT extends QueryFactory<infer Result, infer Args, any, any>\n\t\t? (args: Args) => Promise<Result>\n\t\t: never;\n\nexport type QueryDefinitionMap<Item> = Record<\n\tstring,\n\tQueryFactory<QueryResult<Item>, any, any, Item>\n>;\n\nexport type QueryMethodMap<Definitions extends QueryDefinitionMap<any>> = {\n\t[K in keyof Definitions]: QueryMethod<Definitions[K]>;\n};\n\nexport function defineQuery<\n\tResult extends QueryResult<Item>,\n\tArgs extends QueryArgs = Record<string, never>,\n\tIndexes extends QueryArgsIndexes<Args, Indexes> = Record<string, never>,\n\tItem = ItemFromQueryResult<Result>,\n>(options: QueryOptions<Result, Args, Indexes, Item>): QueryFactory<Result, Args, Indexes, Item> {\n\treturn (store: CacheStore<Item>, name: string) => {\n\t\tconst tag: QueryTag = {\n\t\t\tname,\n\t\t\trevision: options.revision,\n\t\t};\n\n\t\tconst resolve = async (args: Args): Promise<Result> => {\n\t\t\tconst fromCache = await store\n\t\t\t\t.getQuery({\n\t\t\t\t\t...tag,\n\t\t\t\t\targs,\n\t\t\t\t})\n\t\t\t\t.catch((err) => {\n\t\t\t\t\tlog.error(err, `Failed to get query result for ${name}. Proceeding without caching.`);\n\t\t\t\t\treturn null;\n\t\t\t\t});\n\n\t\t\tif (fromCache != null) {\n\t\t\t\treturn fromCache.query as Result;\n\t\t\t}\n\n\t\t\tconst data = await options.resolve(args);\n\n\t\t\tawait store\n\t\t\t\t.saveQuery({\n\t\t\t\t\t...tag,\n\t\t\t\t\targs,\n\t\t\t\t\tdata,\n\t\t\t\t\tindexes: buildIndexes(args, options.indexArgsBy),\n\t\t\t\t})\n\t\t\t\t.catch((err) => {\n\t\t\t\t\tlog.error(err, `Failed to save query result for ${name}. Proceeding without caching.`);\n\t\t\t\t});\n\n\t\t\treturn data;\n\t\t};\n\n\t\tconst invalidateAll = async () => {\n\t\t\tawait store.deleteQueries({\n\t\t\t\t...tag,\n\t\t\t\tindexes: [],\n\t\t\t});\n\t\t};\n\n\t\tconst invalidateByArgs = async (\n\t\t\targs: Partial<IndexedQueryArgs<Args, Indexes>> | Partial<IndexedQueryArgs<Args, Indexes>>[],\n\t\t) => {\n\t\t\tconst argsArray = Array.isArray(args) ? args : [args];\n\t\t\tconst deletePromises = argsArray.map((args) =>\n\t\t\t\tstore.deleteQueries({\n\t\t\t\t\t...tag,\n\t\t\t\t\tindexes: buildIndexes(args, options.indexArgsBy),\n\t\t\t\t}),\n\t\t\t);\n\t\t\tawait Promise.all(deletePromises);\n\t\t};\n\n\t\tconst helpers: QueryHelpersWithIndexes<Args, Indexes> = {\n\t\t\tinvalidateAll,\n\t\t\tinvalidateByArgs,\n\t\t};\n\t\tconst helpersCast: QueryHelpers<Args, Indexes> = helpers as QueryHelpers<Args, Indexes>;\n\n\t\tconst { onUpdate, onDelete, onInsert } = options;\n\n\t\tconst hooks = {\n\t\t\tonUpdate: hookWithHelpers(helpersCast, onUpdate),\n\t\t\tonInsert: hookWithHelpers(helpersCast, onInsert),\n\t\t\tonDelete: hookWithHelpers(helpersCast, onDelete),\n\t\t};\n\n\t\treturn {\n\t\t\tcall: resolve,\n\t\t\ttag,\n\t\t\thelpers,\n\t\t\thooks,\n\t\t};\n\t};\n}\n\nfunction hookWithHelpers<Helpers, Args>(\n\thelpers: Helpers,\n\thook?: (args: Args, helpers: Helpers) => void | Promise<void>,\n) {\n\tif (!hook) {\n\t\treturn undefined;\n\t}\n\tconst hookWithHelpers = async (args: Args) => {\n\t\tawait hook(args, helpers);\n\t};\n\treturn hookWithHelpers;\n}\n\nfunction buildIndexes<Args extends QueryArgs, Indexes extends QueryArgsIndexes<Args, Indexes>>(\n\targs: Partial<Args>,\n\tindexArgsBy?: Indexes,\n): QueryIndex[] {\n\tif (!indexArgsBy) {\n\t\treturn [];\n\t}\n\tconst indexes: QueryIndex[] = [];\n\tfor (const key in indexArgsBy) {\n\t\tif (!Object.hasOwn(args, key)) {\n\t\t\tcontinue;\n\t\t}\n\t\tconst value = args[key];\n\t\tif (value === undefined) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (Array.isArray(value)) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tcontinue;\n\t\t}\n\t\tindexes.push([key, value]);\n\t}\n\treturn indexes;\n}\n"],"mappings":"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"}

package/dist/sdk/index.d.ts

@@ -0,0 +1,5 @@
+//#region sdk/batch.d.ts
+declare function doBatched<T>(items: T[], batchSize: number, fn: (batch: T[]) => Promise<void>): Promise<void>;
+//#endregion
+export { doBatched };
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/index.js

@@ -0,0 +1,8 @@
+//#region sdk/batch.ts
+async function doBatched(items, batchSize, fn) {
+	for (let i = 0; i < items.length; i += batchSize) await fn(items.slice(i, i + batchSize));
+}
+//#endregion
+export { doBatched };
+
+//# sourceMappingURL=index.js.map

package/dist/sdk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../sdk/batch.ts"],"sourcesContent":["export async function doBatched<T>(\n\titems: T[],\n\tbatchSize: number,\n\tfn: (batch: T[]) => Promise<void>,\n): Promise<void> {\n\tfor (let i = 0; i < items.length; i += batchSize) {\n\t\tconst batch = items.slice(i, i + batchSize);\n\t\tawait fn(batch);\n\t}\n}\n"],"mappings":";AAAA,eAAsB,UACrB,OACA,WACA,IACgB;AAChB,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,UAEtC,OAAM,GADQ,MAAM,MAAM,GAAG,IAAI,UAAU,CAC5B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baeta/cache",
-  "version": "0.0.0",
+  "version": "2.0.0-next.12",
   "keywords": [
     "baeta",
     "graphql",
@@ -25,13 +25,75 @@
     "url": "https://github.com/andreisergiu98"
   },
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./sdk": {
+      "types": "./dist/sdk/index.d.ts",
+      "default": "./dist/sdk/index.js"
+    }
+  },
+  "types": "dist/index.d.ts",
   "files": [
+    "dist",
     "package.json"
   ],
+  "scripts": {
+    "build": "builder build",
+    "check:deps": "builder check-deps",
+    "prepack": "builder prepare",
+    "postpack": "builder prepare --restore",
+    "test": "builder test --skip-coverage",
+    "test:circular": "builder test-circular",
+    "types": "tsc --noEmit"
+  },
+  "ava": {
+    "extensions": {
+      "ts": "module"
+    }
+  },
+  "dependencies": {
+    "@baeta/util-encoding": "^2.0.0-next.3",
+    "@baeta/util-log": "^2.0.0-next.3",
+    "dataloader": "^2.2.3",
+    "ohash": "^2.0.11"
+  },
+  "devDependencies": {
+    "@baeta/builder": "^0.0.0",
+    "@baeta/testing": "^0.0.0",
+    "@baeta/tsconfig": "^0.0.0",
+    "typescript": "^5.9.3"
+  },
   "engines": {
     "node": ">=22.20.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./sdk": {
+        "types": "./dist/sdk/index.d.ts",
+        "default": "./dist/sdk/index.js"
+      }
+    }
+  },
+  "typedocOptions": {
+    "entryPoints": [
+      "./index.ts",
+      "./sdk/index.ts"
+    ],
+    "readme": "none",
+    "tsconfig": "./tsconfig.json",
+    "sort": [
+      "kind",
+      "instance-first",
+      "required-first",
+      "alphabetical-ignoring-documents"
+    ]
   }
-}
+}

package/sdk/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@baeta/cache/sdk",
+  "types": "../dist/sdk/index.d.ts",
+  "type": "module"
+}