use-abcd 1.4.3 → 1.6.0

package/dist/item.d.ts

@@ -1,7 +1,9 @@
 import { Draft } from 'mutative';
 import { Collection } from './collection';
 import { ItemStatus } from './types';
-export declare class Item<T extends object, C = unknown> {
+export declare class Item<T extends {
+    id: string;
+}, C = unknown> {
     private _collection;
     private _id;
     private _cachedStatus;
@@ -13,5 +15,4 @@ export declare class Item<T extends object, C = unknown> {
     getStatus(): ItemStatus;
     exists(): boolean;
     get collection(): Collection<T, C>;
-    _updateId(newId: string): void;
 }

package/dist/mocks/handlers.d.ts

@@ -1,2 +1 @@
 export declare const handlers: import('msw').HttpHandler[];
-export declare const batchHandlers: import('msw').HttpHandler[];

package/dist/node.d.ts

@@ -6,6 +6,7 @@ export type TreeNode<T, NodeType = string> = {
     position: number;
     value: T;
     type: NodeType;
+    clientUpdatedAt?: number;
 };
 export declare class Node<T extends object, C = unknown, NodeType = string> {
     private _id;
@@ -19,9 +20,13 @@ export declare class Node<T extends object, C = unknown, NodeType = string> {
     get depth(): number;
     exists(): boolean;
     getStatus(): ItemStatus;
+    private _touch;
     getParent(): Node<T, C, NodeType> | null;
     getChildren(): Node<T, C, NodeType>[];
     private _generateChildId;
+    moveUp(): void;
+    moveDown(): void;
+    setPosition(targetIndex: number): void;
     append(value: T, type?: NodeType): string;
     prepend(value: T, type?: NodeType): string;
     /**
@@ -46,5 +51,4 @@ export declare class Node<T extends object, C = unknown, NodeType = string> {
     updateProp(mutate: (draft: Draft<T>) => void): void;
     remove(): void;
     select(): void;
-    _updateId(newId: string): void;
 }

package/dist/runtime/client.d.ts

@@ -1,52 +1,14 @@
-import { Change, SyncResult } from '../types';
-import { SyncHandlerResult, SyncBatchResult, categorizeResults } from './types';
-export type { SyncHandlerResult, SyncBatchResult };
-export { categorizeResults };
-export type CreateHandler<T> = (data: T, signal: AbortSignal) => Promise<SyncHandlerResult>;
-export type UpdateHandler<T> = (id: string, data: T, signal: AbortSignal) => Promise<SyncHandlerResult>;
-export type DeleteHandler<T> = (id: string, data: T, signal: AbortSignal) => Promise<SyncHandlerResult>;
-export type SyncBuilderConfig<T> = {
-    create?: CreateHandler<T>;
-    update?: UpdateHandler<T>;
-    delete?: DeleteHandler<T>;
-};
-export type SyncBuilder<T, C = unknown> = {
-    onSync: (changes: Change<T>[], context: C, signal: AbortSignal) => Promise<SyncResult[]>;
-    handlers: {
-        create?: CreateHandler<T>;
-        update?: UpdateHandler<T>;
-        delete?: DeleteHandler<T>;
-    };
-};
-export type FetchToSyncResultOptions = {
-    fetch: Promise<Response>;
-    parseResponse?: (response: Response) => Promise<{
-        newId?: string;
-    }>;
-    parseError?: string | ((error: unknown) => string);
-};
-export declare function createSyncClient<T, C = unknown>(config: SyncBuilderConfig<T>): SyncBuilder<T, C>;
-export declare function createSyncClientWithStats<T, C = unknown>(config: SyncBuilderConfig<T>): {
-    onSync: (changes: Change<T>[], context: C, signal: AbortSignal) => Promise<SyncResult[]>;
-    onSyncWithStats: (changes: Change<T>[], context: C, signal: AbortSignal) => Promise<SyncBatchResult>;
-    handlers: {
-        create?: CreateHandler<T>;
-        update?: UpdateHandler<T>;
-        delete?: DeleteHandler<T>;
-    };
-};
-export declare function syncSuccess(options?: {
-    newId?: string;
-}): SyncHandlerResult;
-export declare function syncError(error: string): SyncHandlerResult;
-export type EndpointSyncClientConfig = {
+import { Change } from '../types';
+import { SyncRequestBody, SyncResponseBody } from './types';
+export type { SyncRequestBody, SyncResponseBody };
+export type SyncClientConfig = {
     endpoint: string;
     headers?: Record<string, string>;
     scope?: string;
 };
-export type EndpointSyncClient<T, Q = unknown> = {
-    onFetch: (query: Q, signal: AbortSignal) => Promise<T[]>;
-    onSync: (changes: Change<T>[], context: Q, signal: AbortSignal) => Promise<SyncResult[]>;
-};
-export declare function createSyncClientFromEndpoint<T, Q = unknown>(config: string | EndpointSyncClientConfig): EndpointSyncClient<T, Q>;
-export declare function fetchToSyncResult(options: FetchToSyncResultOptions): Promise<SyncHandlerResult>;
+export declare function createSyncClient<T extends {
+    id: string;
+}, Q = unknown>(config: string | SyncClientConfig): (params: {
+    query?: Q;
+    changes?: Change<T>[];
+}, signal: AbortSignal) => Promise<SyncResponseBody<T>>;

package/dist/runtime/client.js

@@ -1,16 +1,8 @@
-import { c } from "../chunks/types-Dy4rYb2N.js";
-import { c as t, b as a, a as n, f as o, d as S, s as y } from "../chunks/client-BfugfaiH.js";
-import { createSyncServer as f, serverSyncError as l, serverSyncSuccess as m } from "./server.js";
+import { c } from "../chunks/client-lHRDCo64.js";
+import { createCrudHandler as a, createSyncServer as n } from "./server.js";
 export {
-  c as categorizeResults,
-  t as createSyncClient,
-  a as createSyncClientFromEndpoint,
-  n as createSyncClientWithStats,
-  f as createSyncServer,
-  o as fetchToSyncResult,
-  l as serverSyncError,
-  m as serverSyncSuccess,
-  S as syncError,
-  y as syncSuccess
+  a as createCrudHandler,
+  c as createSyncClient,
+  n as createSyncServer
 };
 //# sourceMappingURL=client.js.map

package/dist/runtime/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}
+{"version":3,"file":"client.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/dist/runtime/index.d.ts

@@ -1,5 +1,5 @@
-export { type SyncHandlerResult, type SyncBatchResult, type Schema, type SyncRequestBody, type SyncResponseBody, categorizeResults, } from './types';
-export { createSyncClient, createSyncClientWithStats, createSyncClientFromEndpoint, syncSuccess, syncError, fetchToSyncResult, } from './client';
-export type { CreateHandler, UpdateHandler, DeleteHandler, SyncBuilderConfig, SyncBuilder, FetchToSyncResultOptions, EndpointSyncClientConfig, EndpointSyncClient, } from './client';
-export { createSyncServer, serverSyncSuccess, serverSyncError } from './server';
-export type { ServerFetchHandler, ServerCreateHandler, ServerUpdateHandler, ServerDeleteHandler, ServerSyncHandlerConfig, ServerSyncHandler, } from './server';
+export type { SyncRequestBody, SyncResponseBody, ServerRecord } from './types';
+export { createSyncClient } from './client';
+export type { SyncClientConfig } from './client';
+export { createSyncServer, createCrudHandler } from './server';
+export type { CrudHandler, SyncServerConfig, FetchResult } from './server';

package/dist/runtime/local.d.ts

@@ -0,0 +1,32 @@
+import { Change, SyncResponse, SyncQueueState } from '../types';
+import { LocalSyncClientConfig } from './types';
+export type { LocalSyncClientConfig };
+export declare function createLocalSyncClient<T extends {
+    id: string;
+}>(config: LocalSyncClientConfig): {
+    handler: (params: {
+        query?: unknown;
+        changes?: Change<T>[];
+    }, signal: AbortSignal) => Promise<SyncResponse<T>>;
+    subscribe: (cb: () => void) => () => void;
+    getState: () => SyncQueueState<T>;
+    pauseSync: () => void;
+    resumeSync: () => void;
+    retrySync: (id?: string) => void;
+    resetDatabase: () => Promise<void>;
+    destroy: () => Promise<void>;
+};
+export declare function useLocalSyncState<T extends {
+    id: string;
+}>(collectionId: string, localClient: ReturnType<typeof createLocalSyncClient<T>>): {
+    isSyncing: boolean;
+    isPaused: boolean;
+    queue: Map<string, Change<T>>;
+    inFlight: Map<string, Change<T>>;
+    errors: Map<string, import('..').SyncError<T>>;
+    pauseSync: () => void;
+    resumeSync: () => void;
+    retrySync: (id?: string) => void;
+    resetDatabase: () => Promise<void>;
+    refetch: () => void;
+};

package/dist/runtime/server.d.ts

@@ -1,37 +1,27 @@
-import { Change, SyncResult } from '../types';
-import { SyncHandlerResult, SyncBatchResult, Schema, SyncRequestBody, SyncResponseBody, categorizeResults } from './types';
-export type { SyncHandlerResult, SyncBatchResult, Schema, SyncRequestBody, SyncResponseBody };
-export { categorizeResults };
-/** Context passed to all handlers containing the parsed request body */
-export type ServerHandlerContext<T, Q = unknown> = {
-    body: SyncRequestBody<T, Q>;
+import { Change } from '../types';
+import { SyncRequestBody, SyncResponseBody, ServerRecord } from './types';
+export type { SyncRequestBody, SyncResponseBody, ServerRecord };
+export type CrudHandler<T, Q = unknown> = (request: {
+    scope?: string;
+    query?: Q;
+    changes?: Change<T>[];
+}) => Promise<SyncResponseBody<T>> | SyncResponseBody<T>;
+export type FetchResult<T, S = unknown> = T[] | {
+    items: T[];
+    serverState?: S;
 };
-export type ServerFetchHandler<T, Q> = (query: Q, ctx: ServerHandlerContext<T, Q>) => Promise<T[]> | T[];
-export type ServerCreateHandler<T, Q = unknown> = (data: T, ctx: ServerHandlerContext<T, Q>) => Promise<SyncHandlerResult> | SyncHandlerResult;
-export type ServerUpdateHandler<T, Q = unknown> = (id: string, data: T, ctx: ServerHandlerContext<T, Q>) => Promise<SyncHandlerResult> | SyncHandlerResult;
-export type ServerDeleteHandler<T, Q = unknown> = (id: string, data: T, ctx: ServerHandlerContext<T, Q>) => Promise<SyncHandlerResult> | SyncHandlerResult;
-export type ServerSyncHandlerConfig<T, Q = unknown> = {
-    schema?: Schema<T>;
-    querySchema?: Schema<Q>;
-    fetch?: ServerFetchHandler<T, Q>;
-    create?: ServerCreateHandler<T, Q>;
-    update?: ServerUpdateHandler<T, Q>;
-    delete?: ServerDeleteHandler<T, Q>;
+export type SyncServerConfig<T extends {
+    id: string;
+}, Q = unknown, S = unknown> = {
+    fetch: (params: {
+        scope?: string;
+        query: Q;
+    }) => Promise<FetchResult<T, S>> | FetchResult<T, S>;
+    create: (record: ServerRecord<T>) => Promise<void> | void;
+    update: (record: ServerRecord<T>) => Promise<void> | void;
+    remove: (record: ServerRecord<T>) => Promise<void> | void;
 };
-export type ServerSyncHandler<T, Q = unknown> = {
-    handler: (request: Request) => Promise<Response>;
-    fetchItems: (query: Q, ctx: ServerHandlerContext<T, Q>) => Promise<T[]>;
-    processChanges: (changes: Change<T>[], ctx: ServerHandlerContext<T, Q>) => Promise<SyncResult[]>;
-    processChangesWithStats: (changes: Change<T>[], ctx: ServerHandlerContext<T, Q>) => Promise<SyncBatchResult>;
-    handlers: {
-        fetch?: ServerFetchHandler<T, Q>;
-        create?: ServerCreateHandler<T, Q>;
-        update?: ServerUpdateHandler<T, Q>;
-        delete?: ServerDeleteHandler<T, Q>;
-    };
-};
-export declare function serverSyncSuccess(options?: {
-    newId?: string;
-}): SyncHandlerResult;
-export declare function serverSyncError(error: string): SyncHandlerResult;
-export declare function createSyncServer<T, Q = unknown>(config: ServerSyncHandlerConfig<T, Q>): ServerSyncHandler<T, Q>;
+export declare function createCrudHandler<T extends {
+    id: string;
+}, Q = unknown, S = unknown>(config: SyncServerConfig<T, Q, S>): CrudHandler<T, Q>;
+export declare function createSyncServer<T, Q = unknown>(handler: CrudHandler<T, Q>): (request: Request) => Promise<Response>;

package/dist/runtime/server.js

@@ -1,121 +1,72 @@
-import { c as h } from "../chunks/types-Dy4rYb2N.js";
-const d = (r, e) => new Response(JSON.stringify(r), {
-  status: e,
-  headers: { "Content-Type": "application/json" }
-}), a = {
-  success: (r) => d(r, 200),
-  methodNotAllowed: () => d({ error: "Method not allowed. Use POST." }, 405),
-  invalidJson: () => d({ error: "Invalid JSON body" }, 400),
-  invalidPayload: () => d({ error: "Request body must contain 'query' and/or 'changes'" }, 400),
-  validationError: (r) => d({ error: `Validation error: ${r}` }, 400),
-  notConfigured: (r) => d({ error: `${r} handler not configured` }, 501),
-  serverError: (r) => d({ error: r instanceof Error ? r.message : "Internal server error" }, 500)
+import { g as i, m as c, i as d } from "../chunks/utils-DL5mgkvm.js";
+const y = {
+  create: "create",
+  update: "update",
+  delete: "remove"
 };
-function p() {
-  return {
-    create: {
-      guard: (r) => !!r.create,
-      execute: (r, e, s) => e.create(r.data, s),
-      toResult: (r, e) => e.success === !0 ? { id: r.id, status: "success", newId: e.newId } : { id: r.id, status: "error", error: e.error },
-      notConfiguredError: "Create handler not configured"
-    },
-    update: {
-      guard: (r) => !!r.update,
-      execute: (r, e, s) => e.update(r.id, r.data, s),
-      toResult: (r, e) => e.success === !0 ? { id: r.id, status: "success" } : { id: r.id, status: "error", error: e.error },
-      notConfiguredError: "Update handler not configured"
-    },
-    delete: {
-      guard: (r) => !!r.delete,
-      execute: (r, e, s) => e.delete(r.id, r.data, s),
-      toResult: (r, e) => e.success === !0 ? { id: r.id, status: "success" } : { id: r.id, status: "error", error: e.error },
-      notConfiguredError: "Delete handler not configured"
+function p(a) {
+  return async (t) => {
+    const r = i(), s = { serverSyncedAt: r };
+    if (t.changes && (s.syncResults = await Promise.all(
+      c(t.changes, async (e) => {
+        try {
+          const n = {
+            id: e.data.id,
+            data: e.data,
+            serverSyncedAt: r,
+            deleted: e.type === "delete"
+          };
+          return await a[y[e.type]](n), { status: "success", id: e.data.id, type: e.type, serverSyncedAt: r };
+        } catch (n) {
+          return {
+            status: "error",
+            id: e.data.id,
+            type: e.type,
+            serverSyncedAt: r,
+            error: n instanceof Error ? n.message : "Unknown error"
+          };
+        }
+      })
+    )), t.query !== void 0) {
+      const e = await a.fetch({ scope: t.scope, query: t.query });
+      d(e) ? s.items = e : (s.items = e.items, s.serverState = e.serverState);
     }
+    return s;
   };
 }
-function y(r, e) {
-  if (!e) return { valid: !0, data: r };
-  const s = e.safeParse(r);
-  return s.success === !0 ? { valid: !0, data: s.data } : { valid: !1, error: s.error.message };
-}
-async function v(r, e, s) {
-  const n = p()[r.type];
-  if (!n)
-    return { id: r.id, status: "error", error: `Unknown change type: ${r.type}` };
-  if (!n.guard(e))
-    return { id: r.id, status: "error", error: n.notConfiguredError };
-  const i = y(r.data, e.schema);
-  if (i.valid === !1)
-    return { id: r.id, status: "error", error: `Validation failed: ${i.error}` };
-  try {
-    const o = await n.execute({ ...r, data: i.data }, e, s);
-    return n.toResult(r, o);
-  } catch (o) {
-    return {
-      id: r.id,
-      status: "error",
-      error: o instanceof Error ? o.message : "Unknown error"
-    };
-  }
-}
-function m(r) {
-  return { success: !0, ...r };
-}
-function C(r) {
-  return { success: !1, error: r };
-}
-function E(r) {
-  const e = async (o, t) => {
-    if (!r.fetch) throw new Error("Fetch handler not configured");
-    return r.fetch(o, t);
-  }, s = async (o, t) => Promise.all(o.map((u) => v(u, r, t))), f = async (o, t) => {
-    const u = await s(o, t);
-    return h(u);
-  }, n = async (o) => {
-    let t;
+const o = (a, t) => new Response(JSON.stringify(a), {
+  status: t,
+  headers: { "Content-Type": "application/json" }
+});
+function l(a) {
+  return async (t) => {
+    if (t.method !== "POST")
+      return o({ error: "Method not allowed. Use POST." }, 405);
+    let r;
     try {
-      t = await o.json();
+      r = await t.json();
     } catch {
-      return a.invalidJson();
-    }
-    if (!t.query && !t.changes)
-      return a.invalidPayload();
-    const u = { body: t }, c = {};
-    if (t.query !== void 0) {
-      if (!r.fetch) return a.notConfigured("Fetch");
-      const l = y(t.query, r.querySchema);
-      if (l.valid === !1) return a.validationError(l.error);
-      c.results = await e(l.data, u);
-    }
-    if (t.changes !== void 0) {
-      if (!Array.isArray(t.changes)) return a.invalidPayload();
-      c.syncResults = await s(t.changes, u);
+      return o({ error: "Invalid JSON body" }, 400);
     }
-    return a.success(c);
-  };
-  return {
-    handler: async (o) => {
-      try {
-        return o.method !== "POST" ? a.methodNotAllowed() : await n(o);
-      } catch (t) {
-        return a.serverError(t);
-      }
-    },
-    fetchItems: e,
-    processChanges: s,
-    processChangesWithStats: f,
-    handlers: {
-      fetch: r.fetch,
-      create: r.create,
-      update: r.update,
-      delete: r.delete
+    if (r.query === void 0 && !r.changes)
+      return o({ error: "Request body must contain 'query' and/or 'changes'" }, 400);
+    try {
+      const s = await a({
+        scope: r.scope,
+        query: r.query,
+        changes: r.changes
+      });
+      return o(s, 200);
+    } catch (s) {
+      return o(
+        { error: s instanceof Error ? s.message : "Internal server error" },
+        500
+      );
     }
   };
 }
 export {
-  h as categorizeResults,
-  E as createSyncServer,
-  C as serverSyncError,
-  m as serverSyncSuccess
+  p as createCrudHandler,
+  l as createSyncServer
 };
 //# sourceMappingURL=server.js.map

package/dist/runtime/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","sources":["../../src/runtime/server.ts"],"sourcesContent":["import type { Change, SyncResult } from \"../types\";\nimport {\n  type SyncHandlerResult,\n  type SyncBatchResult,\n  type Schema,\n  type SyncRequestBody,\n  type SyncResponseBody,\n  categorizeResults,\n} from \"./types\";\n\n// Re-export shared types for server module consumers\nexport type { SyncHandlerResult, SyncBatchResult, Schema, SyncRequestBody, SyncResponseBody };\nexport { categorizeResults };\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** Context passed to all handlers containing the parsed request body */\nexport type ServerHandlerContext<T, Q = unknown> = {\n  body: SyncRequestBody<T, Q>;\n};\n\nexport type ServerFetchHandler<T, Q> = (\n  query: Q,\n  ctx: ServerHandlerContext<T, Q>,\n) => Promise<T[]> | T[];\nexport type ServerCreateHandler<T, Q = unknown> = (\n  data: T,\n  ctx: ServerHandlerContext<T, Q>,\n) => Promise<SyncHandlerResult> | SyncHandlerResult;\nexport type ServerUpdateHandler<T, Q = unknown> = (\n  id: string,\n  data: T,\n  ctx: ServerHandlerContext<T, Q>,\n) => Promise<SyncHandlerResult> | SyncHandlerResult;\nexport type ServerDeleteHandler<T, Q = unknown> = (\n  id: string,\n  data: T,\n  ctx: ServerHandlerContext<T, Q>,\n) => Promise<SyncHandlerResult> | SyncHandlerResult;\n\nexport type ServerSyncHandlerConfig<T, Q = unknown> = {\n  schema?: Schema<T>;\n  querySchema?: Schema<Q>;\n  fetch?: ServerFetchHandler<T, Q>;\n  create?: ServerCreateHandler<T, Q>;\n  update?: ServerUpdateHandler<T, Q>;\n  delete?: ServerDeleteHandler<T, Q>;\n};\n\nexport type ServerSyncHandler<T, Q = unknown> = {\n  handler: (request: Request) => Promise<Response>;\n  fetchItems: (query: Q, ctx: ServerHandlerContext<T, Q>) => Promise<T[]>;\n  processChanges: (changes: Change<T>[], ctx: ServerHandlerContext<T, Q>) => Promise<SyncResult[]>;\n  processChangesWithStats: (\n    changes: Change<T>[],\n    ctx: ServerHandlerContext<T, Q>,\n  ) => Promise<SyncBatchResult>;\n  handlers: {\n    fetch?: ServerFetchHandler<T, Q>;\n    create?: ServerCreateHandler<T, Q>;\n    update?: ServerUpdateHandler<T, Q>;\n    delete?: ServerDeleteHandler<T, Q>;\n  };\n};\n\n// ============================================================================\n// Response Helpers\n// ============================================================================\n\nconst jsonResponse = (body: unknown, status: number): Response =>\n  new Response(JSON.stringify(body), {\n    status,\n    headers: { \"Content-Type\": \"application/json\" },\n  });\n\nconst responses = {\n  success: (data: unknown) => jsonResponse(data, 200),\n  methodNotAllowed: () => jsonResponse({ error: \"Method not allowed. Use POST.\" }, 405),\n  invalidJson: () => jsonResponse({ error: \"Invalid JSON body\" }, 400),\n  invalidPayload: () =>\n    jsonResponse({ error: \"Request body must contain 'query' and/or 'changes'\" }, 400),\n  validationError: (message: string) =>\n    jsonResponse({ error: `Validation error: ${message}` }, 400),\n  notConfigured: (handler: string) =>\n    jsonResponse({ error: `${handler} handler not configured` }, 501),\n  serverError: (error: unknown) =>\n    jsonResponse({ error: error instanceof Error ? error.message : \"Internal server error\" }, 500),\n} as const;\n\n// ============================================================================\n// Change Processing\n// ============================================================================\n\ntype ChangeProcessor<T, Q> = {\n  guard: (config: ServerSyncHandlerConfig<T, Q>) => boolean;\n  execute: (\n    change: Change<T>,\n    config: ServerSyncHandlerConfig<T, Q>,\n    ctx: ServerHandlerContext<T, Q>,\n  ) => Promise<SyncHandlerResult> | SyncHandlerResult;\n  toResult: (change: Change<T>, result: SyncHandlerResult) => SyncResult;\n  notConfiguredError: string;\n};\n\nfunction createChangeProcessors<T, Q>(): Record<string, ChangeProcessor<T, Q>> {\n  return {\n    create: {\n      guard: (config) => !!config.create,\n      execute: (change, config, ctx) => config.create!(change.data, ctx),\n      toResult: (change, result) =>\n        result.success === true\n          ? { id: change.id, status: \"success\" as const, newId: result.newId }\n          : { id: change.id, status: \"error\" as const, error: result.error },\n      notConfiguredError: \"Create handler not configured\",\n    },\n\n    update: {\n      guard: (config) => !!config.update,\n      execute: (change, config, ctx) => config.update!(change.id, change.data, ctx),\n      toResult: (change, result) =>\n        result.success === true\n          ? { id: change.id, status: \"success\" as const }\n          : { id: change.id, status: \"error\" as const, error: result.error },\n      notConfiguredError: \"Update handler not configured\",\n    },\n\n    delete: {\n      guard: (config) => !!config.delete,\n      execute: (change, config, ctx) => config.delete!(change.id, change.data, ctx),\n      toResult: (change, result) =>\n        result.success === true\n          ? { id: change.id, status: \"success\" as const }\n          : { id: change.id, status: \"error\" as const, error: result.error },\n      notConfiguredError: \"Delete handler not configured\",\n    },\n  };\n}\n\nfunction validateData<T>(\n  data: unknown,\n  schema?: Schema<T>,\n): { valid: true; data: T } | { valid: false; error: string } {\n  if (!schema) return { valid: true, data: data as T };\n\n  const result = schema.safeParse(data);\n  return result.success === true\n    ? { valid: true, data: result.data }\n    : { valid: false, error: result.error.message };\n}\n\nasync function processServerChange<T, Q>(\n  change: Change<T>,\n  config: ServerSyncHandlerConfig<T, Q>,\n  ctx: ServerHandlerContext<T, Q>,\n): Promise<SyncResult> {\n  const processors = createChangeProcessors<T, Q>();\n  const processor = processors[change.type];\n\n  if (!processor) {\n    return { id: change.id, status: \"error\", error: `Unknown change type: ${change.type}` };\n  }\n\n  if (!processor.guard(config)) {\n    return { id: change.id, status: \"error\", error: processor.notConfiguredError };\n  }\n\n  const validation = validateData(change.data, config.schema);\n  if (validation.valid === false) {\n    return { id: change.id, status: \"error\", error: `Validation failed: ${validation.error}` };\n  }\n\n  try {\n    const result = await processor.execute({ ...change, data: validation.data }, config, ctx);\n    return processor.toResult(change, result);\n  } catch (error) {\n    return {\n      id: change.id,\n      status: \"error\",\n      error: error instanceof Error ? error.message : \"Unknown error\",\n    };\n  }\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport function serverSyncSuccess(options?: { newId?: string }): SyncHandlerResult {\n  return { success: true, ...options };\n}\n\nexport function serverSyncError(error: string): SyncHandlerResult {\n  return { success: false, error };\n}\n\nexport function createSyncServer<T, Q = unknown>(\n  config: ServerSyncHandlerConfig<T, Q>,\n): ServerSyncHandler<T, Q> {\n  const fetchItems = async (query: Q, ctx: ServerHandlerContext<T, Q>): Promise<T[]> => {\n    if (!config.fetch) throw new Error(\"Fetch handler not configured\");\n    return config.fetch(query, ctx);\n  };\n\n  const processChanges = async (\n    changes: Change<T>[],\n    ctx: ServerHandlerContext<T, Q>,\n  ): Promise<SyncResult[]> => {\n    return Promise.all(changes.map((change) => processServerChange(change, config, ctx)));\n  };\n\n  const processChangesWithStats = async (\n    changes: Change<T>[],\n    ctx: ServerHandlerContext<T, Q>,\n  ): Promise<SyncBatchResult> => {\n    const results = await processChanges(changes, ctx);\n    return categorizeResults(results);\n  };\n\n  const handlePost = async (request: Request): Promise<Response> => {\n    let body: SyncRequestBody<T, Q>;\n    try {\n      body = await request.json();\n    } catch {\n      return responses.invalidJson();\n    }\n\n    if (!body.query && !body.changes) {\n      return responses.invalidPayload();\n    }\n\n    const ctx: ServerHandlerContext<T, Q> = { body };\n    const responseBody: SyncResponseBody<T> = {};\n\n    if (body.query !== undefined) {\n      if (!config.fetch) return responses.notConfigured(\"Fetch\");\n\n      const validation = validateData<Q>(body.query, config.querySchema);\n      if (validation.valid === false) return responses.validationError(validation.error);\n\n      responseBody.results = await fetchItems(validation.data, ctx);\n    }\n\n    if (body.changes !== undefined) {\n      if (!Array.isArray(body.changes)) return responses.invalidPayload();\n      responseBody.syncResults = await processChanges(body.changes, ctx);\n    }\n\n    return responses.success(responseBody);\n  };\n\n  const handler = async (request: Request): Promise<Response> => {\n    try {\n      if (request.method !== \"POST\") return responses.methodNotAllowed();\n      return await handlePost(request);\n    } catch (error) {\n      return responses.serverError(error);\n    }\n  };\n\n  return {\n    handler,\n    fetchItems,\n    processChanges,\n    processChangesWithStats,\n    handlers: {\n      fetch: config.fetch,\n      create: config.create,\n      update: config.update,\n      delete: config.delete,\n    },\n  };\n}\n"],"names":["jsonResponse","body","status","responses","data","message","handler","error","createChangeProcessors","config","change","ctx","result","validateData","schema","processServerChange","processor","validation","serverSyncSuccess","options","serverSyncError","createSyncServer","fetchItems","query","processChanges","changes","processChangesWithStats","results","categorizeResults","handlePost","request","responseBody"],"mappings":"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"}
+{"version":3,"file":"server.js","sources":["../../src/runtime/server.ts"],"sourcesContent":["import { isArray, map } from \"lodash-es\";\nimport type { Change, Result } from \"../types\";\nimport type { SyncRequestBody, SyncResponseBody, ServerRecord } from \"./types\";\nimport { getIdFromTime } from \"../utils\";\n\nexport type { SyncRequestBody, SyncResponseBody, ServerRecord };\n\nexport type CrudHandler<T, Q = unknown> = (request: {\n  scope?: string;\n  query?: Q;\n  changes?: Change<T>[];\n}) => Promise<SyncResponseBody<T>> | SyncResponseBody<T>;\n\nexport type FetchResult<T, S = unknown> = T[] | { items: T[]; serverState?: S };\n\nexport type SyncServerConfig<T extends { id: string }, Q = unknown, S = unknown> = {\n  fetch: (params: { scope?: string; query: Q }) => Promise<FetchResult<T, S>> | FetchResult<T, S>;\n  create: (record: ServerRecord<T>) => Promise<void> | void;\n  update: (record: ServerRecord<T>) => Promise<void> | void;\n  remove: (record: ServerRecord<T>) => Promise<void> | void;\n};\n\nconst operations: Record<string, \"create\" | \"update\" | \"remove\"> = {\n  create: \"create\",\n  update: \"update\",\n  delete: \"remove\",\n};\n\nexport function createCrudHandler<T extends { id: string }, Q = unknown, S = unknown>(\n  config: SyncServerConfig<T, Q, S>,\n): CrudHandler<T, Q> {\n  return async (request) => {\n    const serverSyncedAt = getIdFromTime();\n    const response: SyncResponseBody<T> = { serverSyncedAt };\n\n    // Process all changes in parallel\n    if (request.changes) {\n      response.syncResults = await Promise.all(\n        map(request.changes, async (change): Promise<Result> => {\n          try {\n            const record: ServerRecord<T> = {\n              id: change.data.id,\n              data: change.data,\n              serverSyncedAt,\n              deleted: change.type === \"delete\",\n            };\n\n            await config[operations[change.type]](record);\n            return { status: \"success\", id: change.data.id, type: change.type, serverSyncedAt };\n          } catch (error) {\n            return {\n              status: \"error\",\n              id: change.data.id,\n              type: change.type,\n              serverSyncedAt,\n              error: error instanceof Error ? error.message : \"Unknown error\",\n            };\n          }\n        }),\n      );\n    }\n\n    if (request.query !== undefined) {\n      const result = await config.fetch({ scope: request.scope, query: request.query });\n      if (isArray(result)) {\n        response.items = result;\n      } else {\n        response.items = result.items;\n        response.serverState = result.serverState;\n      }\n    }\n\n    return response;\n  };\n}\n\nconst jsonResponse = (body: unknown, status: number): Response =>\n  new Response(JSON.stringify(body), {\n    status,\n    headers: { \"Content-Type\": \"application/json\" },\n  });\n\nexport function createSyncServer<T, Q = unknown>(handler: CrudHandler<T, Q>) {\n  return async (request: Request): Promise<Response> => {\n    if (request.method !== \"POST\") {\n      return jsonResponse({ error: \"Method not allowed. Use POST.\" }, 405);\n    }\n\n    let body: SyncRequestBody<T, Q>;\n    try {\n      body = await request.json();\n    } catch {\n      return jsonResponse({ error: \"Invalid JSON body\" }, 400);\n    }\n\n    if (body.query === undefined && !body.changes) {\n      return jsonResponse({ error: \"Request body must contain 'query' and/or 'changes'\" }, 400);\n    }\n\n    try {\n      const result = await handler({\n        scope: body.scope,\n        query: body.query,\n        changes: body.changes,\n      });\n      return jsonResponse(result, 200);\n    } catch (error) {\n      return jsonResponse(\n        { error: error instanceof Error ? error.message : \"Internal server error\" },\n        500,\n      );\n    }\n  };\n}\n"],"names":["operations","createCrudHandler","config","request","serverSyncedAt","getIdFromTime","response","map","change","record","error","result","isArray","jsonResponse","body","status","createSyncServer","handler"],"mappings":";AAsBA,MAAMA,IAA6D;AAAA,EACjE,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AACV;AAEO,SAASC,EACdC,GACmB;AACnB,SAAO,OAAOC,MAAY;AACxB,UAAMC,IAAiBC,EAAA,GACjBC,IAAgC,EAAE,gBAAAF,EAAA;AA6BxC,QA1BID,EAAQ,YACVG,EAAS,cAAc,MAAM,QAAQ;AAAA,MACnCC,EAAIJ,EAAQ,SAAS,OAAOK,MAA4B;AACtD,YAAI;AACF,gBAAMC,IAA0B;AAAA,YAC9B,IAAID,EAAO,KAAK;AAAA,YAChB,MAAMA,EAAO;AAAA,YACb,gBAAAJ;AAAA,YACA,SAASI,EAAO,SAAS;AAAA,UAAA;AAG3B,uBAAMN,EAAOF,EAAWQ,EAAO,IAAI,CAAC,EAAEC,CAAM,GACrC,EAAE,QAAQ,WAAW,IAAID,EAAO,KAAK,IAAI,MAAMA,EAAO,MAAM,gBAAAJ,EAAA;AAAA,QACrE,SAASM,GAAO;AACd,iBAAO;AAAA,YACL,QAAQ;AAAA,YACR,IAAIF,EAAO,KAAK;AAAA,YAChB,MAAMA,EAAO;AAAA,YACb,gBAAAJ;AAAA,YACA,OAAOM,aAAiB,QAAQA,EAAM,UAAU;AAAA,UAAA;AAAA,QAEpD;AAAA,MACF,CAAC;AAAA,IAAA,IAIDP,EAAQ,UAAU,QAAW;AAC/B,YAAMQ,IAAS,MAAMT,EAAO,MAAM,EAAE,OAAOC,EAAQ,OAAO,OAAOA,EAAQ,MAAA,CAAO;AAChF,MAAIS,EAAQD,CAAM,IAChBL,EAAS,QAAQK,KAEjBL,EAAS,QAAQK,EAAO,OACxBL,EAAS,cAAcK,EAAO;AAAA,IAElC;AAEA,WAAOL;AAAA,EACT;AACF;AAEA,MAAMO,IAAe,CAACC,GAAeC,MACnC,IAAI,SAAS,KAAK,UAAUD,CAAI,GAAG;AAAA,EACjC,QAAAC;AAAA,EACA,SAAS,EAAE,gBAAgB,mBAAA;AAC7B,CAAC;AAEI,SAASC,EAAiCC,GAA4B;AAC3E,SAAO,OAAOd,MAAwC;AACpD,QAAIA,EAAQ,WAAW;AACrB,aAAOU,EAAa,EAAE,OAAO,gCAAA,GAAmC,GAAG;AAGrE,QAAIC;AACJ,QAAI;AACF,MAAAA,IAAO,MAAMX,EAAQ,KAAA;AAAA,IACvB,QAAQ;AACN,aAAOU,EAAa,EAAE,OAAO,oBAAA,GAAuB,GAAG;AAAA,IACzD;AAEA,QAAIC,EAAK,UAAU,UAAa,CAACA,EAAK;AACpC,aAAOD,EAAa,EAAE,OAAO,qDAAA,GAAwD,GAAG;AAG1F,QAAI;AACF,YAAMF,IAAS,MAAMM,EAAQ;AAAA,QAC3B,OAAOH,EAAK;AAAA,QACZ,OAAOA,EAAK;AAAA,QACZ,SAASA,EAAK;AAAA,MAAA,CACf;AACD,aAAOD,EAAaF,GAAQ,GAAG;AAAA,IACjC,SAASD,GAAO;AACd,aAAOG;AAAA,QACL,EAAE,OAAOH,aAAiB,QAAQA,EAAM,UAAU,wBAAA;AAAA,QAClD;AAAA,MAAA;AAAA,IAEJ;AAAA,EACF;AACF;"}

package/dist/runtime/types.d.ts

@@ -1,72 +1,37 @@
-import { Change, SyncResult } from '../types';
-/**
- * Result of a sync operation handler.
- * Used by both client-side and server-side handlers.
- */
-export type SyncHandlerResult = {
-    success: true;
-    newId?: string;
-} | {
-    success: false;
-    error: string;
+import { Change, ChangeType, SyncResponse } from '../types';
+export type ServerRecord<T> = {
+    id: string;
+    data: T;
+    serverSyncedAt: string;
+    deleted: boolean;
 };
-/**
- * Zod-like schema interface (duck typing to avoid hard dependency)
- */
-export type Schema<T> = {
-    safeParse: (data: unknown) => {
-        success: true;
-        data: T;
-    } | {
-        success: false;
-        error: {
-            message: string;
-        };
-    };
+export type LocalRecord<T> = {
+    id: string;
+    data: T;
+    serverSyncedAt: string;
+    deleted: boolean;
+    lastOperation: ChangeType;
 };
-/**
- * Aggregated results from sync operations.
- * Provides categorized results and summary statistics.
- */
-export type SyncBatchResult = {
-    /** All results from the sync operation */
-    results: SyncResult[];
-    /** Results that succeeded */
-    successful: SyncResult[];
-    /** Results that failed */
-    failed: SyncResult[];
-    /** Whether all operations succeeded */
-    allSucceeded: boolean;
-    /** Whether any operations succeeded */
-    anySucceeded: boolean;
-    /** Summary counts */
-    summary: {
-        total: number;
-        succeeded: number;
-        failed: number;
-    };
+export type MetadataRecord = {
+    id: string;
+    value: string;
+};
+export type LocalSyncClientConfig = {
+    dbName: string;
+    version?: number;
+    remoteSyncEndpoint?: string;
+    headers?: Record<string, string>;
+    scope?: string;
+    collectionId?: string;
+    debounce?: number;
+    maxRetries?: number;
+    batchSize?: number;
 };
-/**
- * Categorize sync results into successful and failed
- */
-export declare function categorizeResults(results: SyncResult[]): SyncBatchResult;
-/**
- * Request body for the unified POST endpoint
- */
 export type SyncRequestBody<T, Q = unknown> = {
-    /** Optional scope identifier for selecting storage on the backend */
     scope?: string;
-    /** Query parameters for fetching items */
     query?: Q;
-    /** Changes to sync */
     changes?: Change<T>[];
 };
-/**
- * Response body from the unified POST endpoint
- */
-export type SyncResponseBody<T> = {
-    /** Fetched items (when query was provided) */
-    results?: T[];
-    /** Sync results (when changes were provided) */
-    syncResults?: SyncResult[];
+export type SyncResponseBody<T, S = unknown> = SyncResponse<T> & {
+    serverState?: S;
 };