entity-repository 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kurt Lee
+
+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,390 @@
+# entity-repository
+
+Type-safe entity caching and state management with RxJS observables and React integration.
+
+## Features
+
+- **Type-safe entity management** - Full TypeScript generics for entity definitions and ID types
+- **In-memory caching** - Fast Map-based cache by table and entity ID
+- **RxJS-based reactivity** - Observable streams for real-time updates
+- **Query layer** - `RecordQuery` for single entities, `ListQuery` for filtered/sorted lists
+- **React integration** - Context provider and hooks for seamless React usage
+- **Request deduplication** - Prevents duplicate fetch requests for the same entity
+- **Real-time event system** - Insert/update/delete events for reactive list updates
+
+## Installation
+
+```bash
+npm install entity-repository rxjs
+```
+
+## Quick Start
+
+### 1. Define your entity types
+
+```typescript
+import type { EntityConfig } from "entity-repository";
+
+// Define the shape of your entities
+type Entities = {
+  users: { id: string; name: string; email: string };
+  posts: { id: string; title: string; authorId: string; createdAt: string };
+};
+
+// Configure which field is the ID for each entity
+const entityConfig = {
+  users: { id: "id" },
+  posts: { id: "id" },
+} as const satisfies EntityConfig<Entities>;
+
+type MyEntityConfig = typeof entityConfig;
+```
+
+### 2. Create the repository
+
+```typescript
+import { Repository } from "entity-repository";
+
+const repository = new Repository<Entities, MyEntityConfig>({
+  entities: entityConfig,
+});
+```
+
+### 3. Basic operations
+
+```typescript
+// Store an entity
+repository.set("users", { id: "1", name: "Alice", email: "alice@example.com" });
+
+// Get an entity (returns null if not cached)
+const user = repository.get("users", { id: "1" });
+
+// Fetch with caching (fetches only if not cached, deduplicates concurrent requests)
+const user = await repository.fetch("users", { id: "1" }, async (id) => {
+  const response = await fetch(`/api/users/${id.id}`);
+  return response.json();
+});
+
+// Delete an entity
+repository.del("users", { id: "1" });
+```
+
+### 4. Reactive subscriptions
+
+```typescript
+// Subscribe to entity changes
+const observable = repository.getObservable("users", { id: "1" });
+observable.subscribe((user) => {
+  console.log("User changed:", user);
+});
+
+// Subscribe to all events for a table (insert/update/delete)
+repository.getEvents("users").subscribe((event) => {
+  if (event.type === "insert") console.log("New user:", event.new);
+  if (event.type === "update") console.log("Updated:", event.old, "->", event.new);
+  if (event.type === "delete") console.log("Deleted:", event.old);
+});
+```
+
+## React Integration
+
+### Setup
+
+```typescript
+import { useMemo } from "react";
+import { createRepositoryContext, Repository } from "entity-repository";
+
+// Create typed context and hooks
+export const {
+  RepositoryProvider,
+  useRepository,
+  useRepositoryQuery,
+  useRepositoryListQuery,
+  useSubscribedState,
+} = createRepositoryContext<Entities, MyEntityConfig>();
+
+// In your app root
+function App() {
+  const repository = useMemo(
+    () => new Repository<Entities, MyEntityConfig>({ entities: entityConfig }),
+    []
+  );
+
+  return (
+    <RepositoryProvider repository={repository}>
+      <YourApp />
+    </RepositoryProvider>
+  );
+}
+```
+
+### useRepositoryQuery - Single entity
+
+```typescript
+function UserProfile({ userId }: { userId: string }) {
+  const { entity: user, status } = useRepositoryQuery(
+    "users",
+    { id: userId },
+    async (id) => {
+      const response = await fetch(`/api/users/${id.id}`);
+      return response.json();
+    }
+  );
+
+  if (status === "fetching") return <div>Loading...</div>;
+  if (status === "error") return <div>Error loading user</div>;
+  if (!user) return <div>User not found</div>;
+
+  return <div>{user.name}</div>;
+}
+```
+
+### useRepositoryListQuery - Entity lists with filter/sort
+
+```typescript
+function UserPosts({ authorId }: { authorId: string }) {
+  const { records: posts, status } = useRepositoryListQuery(
+    "posts",
+    { authorId },  // param - query re-runs when this changes
+    {
+      filter: (post) => post.authorId === authorId,
+      order: (a, b) => b.createdAt.localeCompare(a.createdAt),
+    },
+    async (param) => {
+      const response = await fetch(`/api/posts?author=${param.authorId}`);
+      return response.json();
+    }
+  );
+
+  if (status === "fetching" && posts.length === 0) return <div>Loading...</div>;
+
+  return (
+    <ul>
+      {posts.map((post) => (
+        <li key={post.id}>{post.title}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### useSubscribedState - Subscribe to any RxJS observable
+
+```typescript
+import { interval } from "rxjs";
+
+function Timer() {
+  const seconds = useSubscribedState(interval(1000), 0);
+  return <div>Seconds: {seconds}</div>;
+}
+```
+
+## Real-time Updates Integration
+
+The repository emits events when entities change. Connect to your real-time backend:
+
+```typescript
+// Example with Supabase Realtime
+useEffect(() => {
+  const channel = supabase
+    .channel("changes")
+    .on("postgres_changes", { event: "*", schema: "public" }, (payload) => {
+      const table = payload.table as keyof Entities;
+
+      if (payload.eventType === "DELETE") {
+        repository.del(table, { id: payload.old.id });
+      } else {
+        repository.set(table, payload.new);
+      }
+    })
+    .subscribe();
+
+  return () => supabase.removeChannel(channel);
+}, [repository, supabase]);
+```
+
+## Advanced Usage
+
+### RecordQuery - Standalone single-entity query
+
+```typescript
+const query = repository.recordQuery("users", { id: "1" }, async (id) => {
+  const response = await fetch(`/api/users/${id.id}`);
+  return response.json();
+});
+
+// Subscribe to state changes
+query.$state.subscribe((state) => {
+  console.log("Status:", state.status);
+  console.log("Entity:", state.entity);
+});
+
+// Manually trigger a fetch
+await query.fetch();
+
+// Cleanup when done
+query.dispose();
+```
+
+### ListQuery - Standalone list query
+
+```typescript
+const query = repository.listQuery(
+  "posts",
+  {
+    filter: (post) => post.authorId === "1",
+    order: (a, b) => b.createdAt.localeCompare(a.createdAt),
+  },
+  async () => {
+    const response = await fetch("/api/posts?author=1");
+    return response.json();
+  }
+);
+
+// Subscribe to records and status separately
+query.$records.subscribe((posts) => {
+  console.log("Posts:", posts);
+});
+
+query.$status.subscribe((status) => {
+  console.log("Status:", status.status);
+});
+
+// Manually trigger a refetch
+await query.refetch();
+
+// Cleanup when done
+query.dispose();
+```
+
+### Cache key utilities
+
+```typescript
+// Get the cache key for an entity ID
+const key = repository.getCacheKey("users", { id: "1" }); // "1"
+
+// Get the cache key from an entity object
+const key = repository.getEntityKey("users", { id: "1", name: "Alice", email: "..." }); // "1"
+```
+
+## API Reference
+
+### Repository
+
+| Method | Description |
+|--------|-------------|
+| `set(table, entity)` | Store entity in cache, emits insert/update event |
+| `get(table, id)` | Get cached entity or null |
+| `del(table, id)` | Remove entity from cache, emits delete event |
+| `fetch(table, id, fetcher)` | Get cached or fetch, deduplicates concurrent requests |
+| `getObservable(table, id)` | BehaviorSubject for entity changes |
+| `getEvents(table)` | Subject emitting insert/update/delete events |
+| `recordQuery(table, id, fetcher)` | Create RecordQuery instance |
+| `listQuery(table, options, fetcher)` | Create ListQuery instance |
+| `getCacheKey(table, id)` | Get cache key string from entity ID |
+| `getEntityKey(table, entity)` | Get cache key string from entity object |
+
+### RecordQuery
+
+Manages single-entity queries with status tracking.
+
+| Property/Method | Description |
+|-----------------|-------------|
+| `$state` | `BehaviorSubject<{ entity, status }>` - subscribe to state changes |
+| `fetch()` | Manually trigger fetch, returns entity |
+| `dispose()` | Cleanup subscriptions |
+
+### ListQuery
+
+Manages list queries with filter/sort and real-time updates.
+
+| Property/Method | Description |
+|-----------------|-------------|
+| `$records` | `BehaviorSubject<Entity[]>` - subscribe to record list |
+| `$status` | `BehaviorSubject<{ status, error? }>` - subscribe to status |
+| `refetch()` | Manually trigger refetch, returns records |
+| `dispose()` | Cleanup subscriptions |
+
+### React Hooks
+
+| Hook | Description |
+|------|-------------|
+| `useRepository()` | Access repository instance from context |
+| `useRepositoryQuery(table, id, fetcher)` | Subscribe to single entity query |
+| `useRepositoryListQuery(table, param, options, fetcher)` | Subscribe to filtered/sorted list query |
+| `useSubscribedState(observable, initial)` | Subscribe to any RxJS observable |
+
+## Types
+
+```typescript
+// Entity configuration - maps tables to their ID field
+type EntityConfig<Definitions> = {
+  [Table in keyof Definitions]: { id: keyof Definitions[Table] & string };
+};
+
+// Entity ID tuple - picks only the ID field from entity
+type EntityIdTuple<Definitions, Config, Table> =
+  Pick<Definitions[Table], Config[Table]["id"]>;
+
+// Entity event types - emitted on insert/update/delete
+type EntityEvent<Entity> = {
+  timestamp: Date;
+} & (
+  | { type: "insert"; new: Entity }
+  | { type: "update"; old: Entity; new: Entity }
+  | { type: "delete"; old: Entity }
+);
+
+// Single-entity query state
+type RepositoryQuery<Entity> = {
+  entity: Entity | null;
+} & (
+  | { status: "fetching" }
+  | { status: "idle" }
+  | { status: "error"; error: Error }
+);
+
+// List query options
+type ListQueryOptions<Entity> = {
+  filter?: (entity: Entity) => boolean;
+  order?: (left: Entity, right: Entity) => number;
+};
+
+// List query status
+type ListQueryStatus =
+  | { status: "idle" }
+  | { status: "fetching" }
+  | { status: "error"; error: Error };
+
+// List query state (returned by useRepositoryListQuery)
+type ListQueryState<Entity> = {
+  records: Entity[];
+} & ListQueryStatus;
+```
+
+## How It Works
+
+### Caching Strategy
+
+The repository uses a simple Map-based cache keyed by table name and entity ID:
+
+1. **Set**: Stores entity and emits insert (new) or update (existing) event
+2. **Get**: Returns cached entity or null (synchronous)
+3. **Fetch**: Returns cached entity, or fetches and caches if not present
+4. **Request deduplication**: Concurrent fetches for the same entity share a single request
+
+### Reactivity
+
+- `getObservable()` returns a `BehaviorSubject` that emits when an entity changes
+- `getEvents()` returns a `Subject` that emits insert/update/delete events for a table
+- `ListQuery` subscribes to table events and automatically updates its filtered list
+
+### React Integration
+
+- `useRepositoryQuery` creates a `RecordQuery` and subscribes to its state
+- `useRepositoryListQuery` creates a `ListQuery` and subscribes to records + status
+- Both hooks use `JSON.stringify(id/param)` for stable memoization keys
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./record-query";
+export * from "./list-query";
+export * from "./repository";
+export * from "./react";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./record-query";
+export * from "./list-query";
+export * from "./repository";
+export * from "./react";

package/dist/list-query.d.ts

@@ -0,0 +1,36 @@
+import { BehaviorSubject } from "rxjs";
+import type { EntityConfig, EntityDefinitions } from "./types";
+import type { Repository } from "./repository";
+export type ListQueryOptions<Entity> = {
+    order?: (left: Entity, right: Entity) => number;
+    filter?: (entity: Entity) => boolean;
+};
+export type ListQueryStatus = {
+    status: "idle";
+} | {
+    status: "fetching";
+} | {
+    status: "error";
+    error: Error;
+};
+export type ListQueryState<Entity> = {
+    records: Entity[];
+} & ListQueryStatus;
+export declare class ListQuery<Definitions extends EntityDefinitions, Config extends EntityConfig<Definitions>, Table extends keyof Definitions> {
+    readonly $records: BehaviorSubject<Definitions[Table][]>;
+    readonly $status: BehaviorSubject<ListQueryStatus>;
+    private repository;
+    private table;
+    private fetcher;
+    private filter;
+    private order;
+    private subscription;
+    constructor(repository: Repository<Definitions, Config>, table: Table, options: ListQueryOptions<Definitions[Table]>, fetcher: () => Promise<Definitions[Table][]>);
+    refetch(): Promise<Definitions[Table][]>;
+    dispose(): void;
+    private applyEvent;
+    private upsertRecord;
+    private removeRecord;
+    private applyOrdering;
+}
+//# sourceMappingURL=list-query.d.ts.map

package/dist/list-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-query.d.ts","sourceRoot":"","sources":["../src/list-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAgB,MAAM,MAAM,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAe,MAAM,SAAS,CAAC;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,gBAAgB,CAAC,MAAM,IAAI;IACrC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,GACtB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAEtC,MAAM,MAAM,cAAc,CAAC,MAAM,IAAI;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,GAAG,eAAe,CAAC;AAEpB,qBAAa,SAAS,CACpB,WAAW,SAAS,iBAAiB,EACrC,MAAM,SAAS,YAAY,CAAC,WAAW,CAAC,EACxC,KAAK,SAAS,MAAM,WAAW;IAE/B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACzD,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;IACnD,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,KAAK,CAA2E;IACxF,OAAO,CAAC,YAAY,CAAe;gBAGjC,UAAU,EAAE,UAAU,CAAC,WAAW,EAAE,MAAM,CAAC,EAC3C,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAC7C,OAAO,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;IAkBxC,OAAO;IAmBb,OAAO;IAIP,OAAO,CAAC,UAAU;IAoBlB,OAAO,CAAC,YAAY;IAyCpB,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,aAAa;CAOtB"}

package/dist/list-query.js

@@ -0,0 +1,109 @@
+import { BehaviorSubject } from "rxjs";
+export class ListQuery {
+    $records;
+    $status;
+    repository;
+    table;
+    fetcher;
+    filter;
+    order;
+    subscription;
+    constructor(repository, table, options, fetcher) {
+        this.repository = repository;
+        this.table = table;
+        this.fetcher = fetcher;
+        this.filter = options.filter ?? (() => true);
+        this.order = options.order ?? null;
+        this.$records = new BehaviorSubject([]);
+        this.$status = new BehaviorSubject({ status: "fetching" });
+        this.subscription = repository.getEvents(table).subscribe((event) => {
+            this.applyEvent(event);
+        });
+        void this.refetch();
+    }
+    async refetch() {
+        this.$status.next({ status: "fetching" });
+        try {
+            const records = await this.fetcher();
+            records.forEach((record) => {
+                this.repository.set(this.table, record);
+            });
+            const nextRecords = this.applyOrdering(records.filter(this.filter));
+            this.$records.next(nextRecords);
+            this.$status.next({ status: "idle" });
+            return nextRecords;
+        }
+        catch (error) {
+            const normalizedError = error instanceof Error ? error : new Error("ListQuery fetch failed");
+            this.$status.next({ status: "error", error: normalizedError });
+            throw normalizedError;
+        }
+    }
+    dispose() {
+        this.subscription.unsubscribe();
+    }
+    applyEvent(event) {
+        const current = this.$records.value;
+        switch (event.type) {
+            case "insert":
+                this.upsertRecord(current, event.new);
+                return;
+            case "update":
+                this.upsertRecord(current, event.new, event.old);
+                return;
+            case "delete":
+                this.removeRecord(current, event.old);
+                return;
+            default: {
+                const _exhaustive = event;
+                return _exhaustive;
+            }
+        }
+    }
+    upsertRecord(current, nextRecord, previousRecord) {
+        const nextPasses = this.filter(nextRecord);
+        const nextKey = this.repository.getEntityKey(this.table, nextRecord);
+        const previousKey = previousRecord
+            ? this.repository.getEntityKey(this.table, previousRecord)
+            : null;
+        const index = current.findIndex((record) => this.repository.getEntityKey(this.table, record) === nextKey);
+        if (!nextPasses) {
+            if (index !== -1) {
+                const next = current.slice();
+                next.splice(index, 1);
+                this.$records.next(this.applyOrdering(next));
+            }
+            return;
+        }
+        const next = current.slice();
+        if (index === -1) {
+            next.push(nextRecord);
+        }
+        else {
+            next[index] = nextRecord;
+        }
+        if (previousKey && previousKey !== nextKey) {
+            const previousIndex = next.findIndex((record, recordIndex) => recordIndex !== index && this.repository.getEntityKey(this.table, record) === previousKey);
+            if (previousIndex !== -1) {
+                next.splice(previousIndex, 1);
+            }
+        }
+        this.$records.next(this.applyOrdering(next));
+    }
+    removeRecord(current, record) {
+        const key = this.repository.getEntityKey(this.table, record);
+        const index = current.findIndex((existing) => this.repository.getEntityKey(this.table, existing) === key);
+        if (index === -1) {
+            return;
+        }
+        const next = current.slice();
+        next.splice(index, 1);
+        this.$records.next(this.applyOrdering(next));
+    }
+    applyOrdering(records) {
+        if (!this.order) {
+            return records;
+        }
+        return [...records].sort(this.order);
+    }
+}

package/dist/react.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+import { type Observable } from "rxjs";
+import type { ListQueryOptions, ListQueryState } from "./list-query";
+import type { EntityConfig, EntityDefinitions, EntityIdTuple, RepositoryQuery } from "./types";
+import { Repository } from "./repository";
+export declare function createRepositoryContext<Definitions extends EntityDefinitions, Config extends EntityConfig<Definitions> = EntityConfig<Definitions>>(): {
+    RepositoryProvider: ({ repository, children, }: {
+        repository: Repository<Definitions, Config>;
+        children: ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    useRepository: () => Repository<Definitions, Config>;
+    useRepositoryQuery: <Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>, fetcher: (id: EntityIdTuple<Definitions, Config, Table>) => Promise<Definitions[Table]>) => RepositoryQuery<Definitions[Table]>;
+    useRepositoryListQuery: <Table extends keyof Definitions, Param>(table: Table, param: Param, options: ListQueryOptions<Definitions[Table]>, fetcher: (param: Param) => Promise<Definitions[Table][]>) => ListQueryState<Definitions[Table]>;
+    useSubscribedState: <Value>(observable: Observable<Value>, initialValue: Value) => Value;
+};
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,SAAS,EAA4C,MAAM,OAAO,CAAC;AAE3F,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAE3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,wBAAgB,uBAAuB,CACrC,WAAW,SAAS,iBAAiB,EACrC,MAAM,SAAS,YAAY,CAAC,WAAW,CAAC,GAAG,YAAY,CAAC,WAAW,CAAC;oDAOjE;QACD,UAAU,EAAE,UAAU,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAC5C,QAAQ,EAAE,SAAS,CAAC;KACrB;;yBAoC2B,KAAK,SAAS,MAAM,WAAW,SAClD,KAAK,MACR,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,WACpC,CAAC,EAAE,EAAE,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,KACtF,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;6BAiBN,KAAK,SAAS,MAAM,WAAW,EAAE,KAAK,SAC7D,KAAK,SACL,KAAK,WACH,gBAAgB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,WACpC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,KACvD,cAAc,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;yBA9CT,KAAK,cAAc,UAAU,CAAC,KAAK,CAAC,gBAAgB,KAAK;EA2EtF"}

package/dist/react.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { combineLatest, map } from "rxjs";
+export function createRepositoryContext() {
+    const RepositoryReactContext = createContext(null);
+    function RepositoryProvider({ repository, children, }) {
+        return (_jsx(RepositoryReactContext.Provider, { value: repository, children: children }));
+    }
+    function useRepository() {
+        const context = useContext(RepositoryReactContext);
+        if (!context) {
+            throw new Error("RepositoryProvider is missing.");
+        }
+        return context;
+    }
+    function useSubscribedState(observable, initialValue) {
+        const [state, setState] = useState(initialValue);
+        useEffect(() => {
+            const subscription = observable.subscribe((value) => {
+                setState(value);
+            });
+            return () => subscription.unsubscribe();
+        }, [observable]);
+        return state;
+    }
+    /**
+     * Subscribes to a single-record query keyed only by `id`.
+     *
+     * NOTE: `table` and `fetcher` changes are intentionally ignored so the
+     * query instance remains stable for a given `id`.
+     */
+    function useRepositoryQuery(table, id, fetcher) {
+        const repository = useRepository();
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- table/fetcher intentionally ignored
+        const recordQuery = useMemo(() => repository.recordQuery(table, id, fetcher), [repository, JSON.stringify(id)]);
+        return useSubscribedState(recordQuery.$state, recordQuery.$state.value);
+    }
+    /**
+     * Subscribes to a list query keyed only by `param`.
+     *
+     * NOTE: `options` and `fetcher` changes are intentionally ignored so the
+     * list query instance remains stable for a given `param`.
+     */
+    function useRepositoryListQuery(table, param, options, fetcher) {
+        const repository = useRepository();
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- table/options/fetcher intentionally ignored
+        const listQuery = useMemo(() => repository.listQuery(table, options, () => fetcher(param)), [repository, JSON.stringify(param)]);
+        useEffect(() => {
+            return () => listQuery.dispose();
+        }, [listQuery]);
+        const $state = useMemo(() => combineLatest([listQuery.$records, listQuery.$status]).pipe(map(([records, status]) => ({ records, ...status }))), [listQuery]);
+        return useSubscribedState($state, { records: listQuery.$records.value, ...listQuery.$status.value });
+    }
+    return {
+        RepositoryProvider,
+        useRepository,
+        useRepositoryQuery,
+        useRepositoryListQuery,
+        useSubscribedState,
+    };
+}

package/dist/record-query.d.ts

@@ -0,0 +1,15 @@
+import { BehaviorSubject } from "rxjs";
+import type { EntityConfig, EntityDefinitions, EntityIdTuple, RepositoryQuery } from "./types";
+import type { Repository } from "./repository";
+export declare class RecordQuery<Definitions extends EntityDefinitions, Config extends EntityConfig<Definitions>, Table extends keyof Definitions> {
+    readonly $state: BehaviorSubject<RepositoryQuery<Definitions[Table]>>;
+    private subscription;
+    private repository;
+    private table;
+    private id;
+    private fetcher;
+    constructor(repository: Repository<Definitions, Config>, table: Table, id: EntityIdTuple<Definitions, Config, Table>, fetcher: (id: EntityIdTuple<Definitions, Config, Table>) => Promise<Definitions[Table]>);
+    fetch(): Promise<Definitions[Table]>;
+    dispose(): void;
+}
+//# sourceMappingURL=record-query.d.ts.map

package/dist/record-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-query.d.ts","sourceRoot":"","sources":["../src/record-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAgB,MAAM,MAAM,CAAC;AAErD,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,eAAe,EAChB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,qBAAa,WAAW,CACtB,WAAW,SAAS,iBAAiB,EACrC,MAAM,SAAS,YAAY,CAAC,WAAW,CAAC,EACxC,KAAK,SAAS,MAAM,WAAW;IAE/B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACtE,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,UAAU,CAAkC;IACpD,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,EAAE,CAA4C;IACtD,OAAO,CAAC,OAAO,CAAiF;gBAG9F,UAAU,EAAE,UAAU,CAAC,WAAW,EAAE,MAAM,CAAC,EAC3C,KAAK,EAAE,KAAK,EACZ,EAAE,EAAE,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,EAC7C,OAAO,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAuBnF,KAAK;IA2BX,OAAO;CAGR"}

package/dist/record-query.js

@@ -0,0 +1,55 @@
+import { BehaviorSubject } from "rxjs";
+export class RecordQuery {
+    $state;
+    subscription;
+    repository;
+    table;
+    id;
+    fetcher;
+    constructor(repository, table, id, fetcher) {
+        this.repository = repository;
+        this.table = table;
+        this.id = id;
+        this.fetcher = fetcher;
+        const entity = repository.get(table, id);
+        const initialState = entity
+            ? { entity, status: "idle" }
+            : { entity: null, status: "fetching" };
+        this.$state = new BehaviorSubject(initialState);
+        this.subscription = repository.getObservable(table, id).subscribe((value) => {
+            this.$state.next({ ...this.$state.value, entity: value });
+        });
+        if (!entity) {
+            void this.fetch();
+        }
+    }
+    async fetch() {
+        const current = this.repository.get(this.table, this.id);
+        if (current) {
+            this.$state.next({ entity: current, status: "idle" });
+            return current;
+        }
+        this.$state.next({ ...this.$state.value, status: "fetching" });
+        try {
+            const value = await this.repository.fetch(this.table, this.id, this.fetcher);
+            this.$state.next({ entity: value, status: "idle" });
+            return value;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.$state.next({ entity: this.$state.value.entity, status: "error", error });
+            }
+            else {
+                this.$state.next({
+                    entity: this.$state.value.entity,
+                    status: "error",
+                    error: new Error("RecordQuery fetch failed"),
+                });
+            }
+            throw error;
+        }
+    }
+    dispose() {
+        this.subscription.unsubscribe();
+    }
+}

package/dist/repository.d.ts

@@ -0,0 +1,24 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import type { EntityConfig, EntityDefinitions, EntityEvent, EntityIdTuple, RepositoryConfig } from "./types";
+import { ListQuery, type ListQueryOptions } from "./list-query";
+import { RecordQuery } from "./record-query";
+export declare class Repository<Definitions extends EntityDefinitions, Config extends EntityConfig<Definitions> = EntityConfig<Definitions>> {
+    private stores;
+    private config;
+    constructor(config: RepositoryConfig<Definitions, Config>);
+    set<Table extends keyof Definitions>(table: Table, entity: Definitions[Table]): void;
+    del<Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>): void;
+    get<Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>): Definitions[Table] | null;
+    fetch<Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>, fetcher: (id: EntityIdTuple<Definitions, Config, Table>) => Promise<Definitions[Table]>): Promise<Definitions[Table]>;
+    getObservable<Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>): BehaviorSubject<Definitions[Table] | null>;
+    getEvents<Table extends keyof Definitions>(table: Table): Subject<EntityEvent<Definitions[Table]>>;
+    recordQuery<Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>, fetcher: (id: EntityIdTuple<Definitions, Config, Table>) => Promise<Definitions[Table]>): RecordQuery<Definitions, Config, Table>;
+    getCacheKey<Table extends keyof Definitions>(table: Table, id: EntityIdTuple<Definitions, Config, Table>): string;
+    getEntityKey<Table extends keyof Definitions>(table: Table, entity: Definitions[Table]): string;
+    listQuery<Table extends keyof Definitions>(table: Table, options: ListQueryOptions<Definitions[Table]>, fetcher: () => Promise<Definitions[Table][]>): ListQuery<Definitions, Config, Table>;
+    private getStore;
+    private getIdKey;
+    private getCacheKeyFromId;
+    private getCacheKeyFromEntity;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../src/repository.ts"],"names":[],"mappings":"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"}

package/dist/repository.js

@@ -0,0 +1,141 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { ListQuery } from "./list-query";
+import { RecordQuery } from "./record-query";
+export class Repository {
+    stores = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    set(table, entity) {
+        const store = this.getStore(table);
+        const cacheKey = this.getCacheKeyFromEntity(table, entity);
+        const existing = store.records.get(cacheKey);
+        store.records.set(cacheKey, entity);
+        if (existing) {
+            store.events$.next({
+                timestamp: new Date(),
+                type: "update",
+                old: existing,
+                new: entity,
+            });
+        }
+        else {
+            store.events$.next({
+                timestamp: new Date(),
+                type: "insert",
+                new: entity,
+            });
+        }
+        const subject = store.subjects.get(cacheKey);
+        if (subject) {
+            subject.next(entity);
+        }
+    }
+    del(table, id) {
+        const store = this.getStore(table);
+        const cacheKey = this.getCacheKeyFromId(table, id);
+        const existing = store.records.get(cacheKey);
+        store.records.delete(cacheKey);
+        if (existing) {
+            store.events$.next({
+                timestamp: new Date(),
+                type: "delete",
+                old: existing,
+            });
+        }
+        const subject = store.subjects.get(cacheKey);
+        if (subject) {
+            subject.next(null);
+        }
+    }
+    get(table, id) {
+        const store = this.getStore(table);
+        const cacheKey = this.getCacheKeyFromId(table, id);
+        const record = store.records.get(cacheKey);
+        return record ?? null;
+    }
+    async fetch(table, id, fetcher) {
+        const store = this.getStore(table);
+        const cacheKey = this.getCacheKeyFromId(table, id);
+        const record = store.records.get(cacheKey);
+        if (record) {
+            return record;
+        }
+        const inflight = store.inflight.get(cacheKey);
+        if (inflight) {
+            return inflight;
+        }
+        const request = (async () => {
+            const value = await fetcher(id);
+            this.set(table, value);
+            return value;
+        })();
+        store.inflight.set(cacheKey, request);
+        request.finally(() => {
+            store.inflight.delete(cacheKey);
+        });
+        return request;
+    }
+    getObservable(table, id) {
+        const store = this.getStore(table);
+        const cacheKey = this.getCacheKeyFromId(table, id);
+        const existing = store.subjects.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        const record = store.records.get(cacheKey);
+        const subject = new BehaviorSubject(record ?? null);
+        store.subjects.set(cacheKey, subject);
+        return subject;
+    }
+    getEvents(table) {
+        const store = this.getStore(table);
+        return store.events$;
+    }
+    recordQuery(table, id, fetcher) {
+        return new RecordQuery(this, table, id, fetcher);
+    }
+    getCacheKey(table, id) {
+        return this.getCacheKeyFromId(table, id);
+    }
+    getEntityKey(table, entity) {
+        return this.getCacheKeyFromEntity(table, entity);
+    }
+    listQuery(table, options, fetcher) {
+        return new ListQuery(this, table, options, fetcher);
+    }
+    getStore(table) {
+        const existing = this.stores.get(table);
+        if (existing) {
+            return existing;
+        }
+        const store = {
+            records: new Map(),
+            subjects: new Map(),
+            inflight: new Map(),
+            events$: new Subject(),
+        };
+        this.stores.set(table, store);
+        return store;
+    }
+    getIdKey(table) {
+        return this.config.entities[table].id;
+    }
+    getCacheKeyFromId(table, id) {
+        const idKey = this.getIdKey(table);
+        const idValue = id[idKey];
+        if (idValue === undefined || idValue === null) {
+            throw new Error(`Missing identifier "${String(idKey)}" for ${String(table)}`);
+        }
+        return String(idValue);
+    }
+    getCacheKeyFromEntity(table, entity) {
+        const idKey = this.getIdKey(table);
+        const idValue = entity[idKey];
+        if (idValue === undefined || idValue === null) {
+            throw new Error(`Missing identifier "${String(idKey)}" for ${String(table)}`);
+        }
+        return String(idValue);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+export type EntityDefinitions = Record<string, Record<string, unknown>>;
+export type EntityConfig<Definitions extends EntityDefinitions> = {
+    [Table in keyof Definitions]: {
+        id: keyof Definitions[Table] & string;
+    };
+};
+export type RepositoryConfig<Definitions extends EntityDefinitions, Config extends EntityConfig<Definitions>> = {
+    entities: Config;
+};
+export type EntityIdTuple<Definitions extends EntityDefinitions, Config extends EntityConfig<Definitions>, Table extends keyof Definitions> = Pick<Definitions[Table], Config[Table]["id"]>;
+export type EntityEvent<Entity> = {
+    timestamp: Date;
+} & ({
+    type: "insert";
+    new: Entity;
+} | {
+    type: "update";
+    old: Entity;
+    new: Entity;
+} | {
+    type: "delete";
+    old: Entity;
+});
+export type RepositoryQuery<Entity> = {
+    entity: Entity | null;
+} & ({
+    status: "fetching";
+} | {
+    status: "idle";
+} | {
+    status: "error";
+    error: Error;
+});
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAExE,MAAM,MAAM,YAAY,CAAC,WAAW,SAAS,iBAAiB,IAAI;KAC/D,KAAK,IAAI,MAAM,WAAW,GAAG;QAAE,EAAE,EAAE,MAAM,WAAW,CAAC,KAAK,CAAC,GAAG,MAAM,CAAA;KAAE;CACxE,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAC1B,WAAW,SAAS,iBAAiB,EACrC,MAAM,SAAS,YAAY,CAAC,WAAW,CAAC,IACtC;IACF,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,aAAa,CACvB,WAAW,SAAS,iBAAiB,EACrC,MAAM,SAAS,YAAY,CAAC,WAAW,CAAC,EACxC,KAAK,SAAS,MAAM,WAAW,IAC7B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AAElD,MAAM,MAAM,WAAW,CAAC,MAAM,IAAI;IAChC,SAAS,EAAE,IAAI,CAAC;CACjB,GAAG,CACA;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAClC,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI;IACpC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,GAAG,CACA;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,GACtB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CACpC,CAAC"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "entity-repository",
+  "version": "0.1.0",
+  "description": "Type-safe entity caching and state management with RxJS and React",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "entity",
+    "repository",
+    "cache",
+    "rxjs",
+    "react",
+    "state-management",
+    "typescript"
+  ],
+  "author": "Kurt Lee",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/breath103/entity-repository.git"
+  },
+  "homepage": "https://github.com/breath103/entity-repository#readme",
+  "bugs": {
+    "url": "https://github.com/breath103/entity-repository/issues"
+  },
+  "dependencies": {
+    "rxjs": "^7.8.1"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.8",
+    "typescript": "^5.9.3"
+  }
+}