@trestleinc/replicate 1.1.1 → 1.1.2-preview.0

package/dist/component/schema.d.ts

@@ -1,46 +1,54 @@
-declare const _default: import("convex/server").SchemaDefinition<{
-    documents: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        collection: string;
-        documentId: string;
-        crdtBytes: ArrayBuffer;
-        version: number;
-        timestamp: number;
-    }, {
-        collection: import("convex/values").VString<string, "required">;
-        documentId: import("convex/values").VString<string, "required">;
-        crdtBytes: import("convex/values").VBytes<ArrayBuffer, "required">;
-        version: import("convex/values").VFloat64<number, "required">;
-        timestamp: import("convex/values").VFloat64<number, "required">;
-    }, "required", "collection" | "documentId" | "crdtBytes" | "version" | "timestamp">, {
-        by_collection: ["collection", "_creationTime"];
-        by_collection_document_version: ["collection", "documentId", "version", "_creationTime"];
-        by_timestamp: ["collection", "timestamp", "_creationTime"];
-    }, {}, {}>;
-    snapshots: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        metadata?: {
-            deltaCount: number;
-            totalSize: number;
-        } | undefined;
-        collection: string;
-        documentId: string;
-        createdAt: number;
-        snapshotBytes: ArrayBuffer;
-        latestCompactionTimestamp: number;
-    }, {
-        collection: import("convex/values").VString<string, "required">;
-        documentId: import("convex/values").VString<string, "required">;
-        snapshotBytes: import("convex/values").VBytes<ArrayBuffer, "required">;
-        latestCompactionTimestamp: import("convex/values").VFloat64<number, "required">;
-        createdAt: import("convex/values").VFloat64<number, "required">;
-        metadata: import("convex/values").VObject<{
-            deltaCount: number;
-            totalSize: number;
-        } | undefined, {
-            deltaCount: import("convex/values").VFloat64<number, "required">;
-            totalSize: import("convex/values").VFloat64<number, "required">;
-        }, "optional", "deltaCount" | "totalSize">;
-    }, "required", "collection" | "documentId" | "createdAt" | "metadata" | "snapshotBytes" | "latestCompactionTimestamp" | "metadata.deltaCount" | "metadata.totalSize">, {
-        by_document: ["collection", "documentId", "_creationTime"];
-    }, {}, {}>;
+import * as convex_server0 from "convex/server";
+import * as convex_values0 from "convex/values";
+
+//#region src/component/schema.d.ts
+declare const _default: convex_server0.SchemaDefinition<{
+  documents: convex_server0.TableDefinition<convex_values0.VObject<{
+    collection: string;
+    documentId: string;
+    crdtBytes: ArrayBuffer;
+    seq: number;
+  }, {
+    collection: convex_values0.VString<string, "required">;
+    documentId: convex_values0.VString<string, "required">;
+    crdtBytes: convex_values0.VBytes<ArrayBuffer, "required">;
+    seq: convex_values0.VFloat64<number, "required">;
+  }, "required", "collection" | "documentId" | "crdtBytes" | "seq">, {
+    by_collection: ["collection", "_creationTime"];
+    by_collection_document: ["collection", "documentId", "_creationTime"];
+    by_seq: ["collection", "seq", "_creationTime"];
+  }, {}, {}>;
+  snapshots: convex_server0.TableDefinition<convex_values0.VObject<{
+    collection: string;
+    documentId: string;
+    snapshotBytes: ArrayBuffer;
+    stateVector: ArrayBuffer;
+    snapshotSeq: number;
+    createdAt: number;
+  }, {
+    collection: convex_values0.VString<string, "required">;
+    documentId: convex_values0.VString<string, "required">;
+    snapshotBytes: convex_values0.VBytes<ArrayBuffer, "required">;
+    stateVector: convex_values0.VBytes<ArrayBuffer, "required">;
+    snapshotSeq: convex_values0.VFloat64<number, "required">;
+    createdAt: convex_values0.VFloat64<number, "required">;
+  }, "required", "collection" | "documentId" | "snapshotBytes" | "stateVector" | "snapshotSeq" | "createdAt">, {
+    by_document: ["collection", "documentId", "_creationTime"];
+  }, {}, {}>;
+  peers: convex_server0.TableDefinition<convex_values0.VObject<{
+    collection: string;
+    peerId: string;
+    lastSyncedSeq: number;
+    lastSeenAt: number;
+  }, {
+    collection: convex_values0.VString<string, "required">;
+    peerId: convex_values0.VString<string, "required">;
+    lastSyncedSeq: convex_values0.VFloat64<number, "required">;
+    lastSeenAt: convex_values0.VFloat64<number, "required">;
+  }, "required", "collection" | "peerId" | "lastSyncedSeq" | "lastSeenAt">, {
+    by_collection: ["collection", "_creationTime"];
+    by_collection_peer: ["collection", "peerId", "_creationTime"];
+  }, {}, {}>;
 }, true>;
-export default _default;
+//#endregion
+export { _default as default };

package/dist/component/schema.js

@@ -1,35 +1,29 @@
 import { defineSchema, defineTable } from "convex/server";
 import { v } from "convex/values";
-const schema = defineSchema({
-    documents: defineTable({
-        collection: v.string(),
-        documentId: v.string(),
-        crdtBytes: v.bytes(),
-        version: v.number(),
-        timestamp: v.number()
-    }).index('by_collection', [
-        'collection'
-    ]).index('by_collection_document_version', [
-        'collection',
-        'documentId',
-        'version'
-    ]).index('by_timestamp', [
-        'collection',
-        'timestamp'
-    ]),
-    snapshots: defineTable({
-        collection: v.string(),
-        documentId: v.string(),
-        snapshotBytes: v.bytes(),
-        latestCompactionTimestamp: v.number(),
-        createdAt: v.number(),
-        metadata: v.optional(v.object({
-            deltaCount: v.number(),
-            totalSize: v.number()
-        }))
-    }).index('by_document', [
-        'collection',
-        'documentId'
-    ])
+
+//#region src/component/schema.ts
+var schema_default = defineSchema({
+	documents: defineTable({
+		collection: v.string(),
+		documentId: v.string(),
+		crdtBytes: v.bytes(),
+		seq: v.number()
+	}).index("by_collection", ["collection"]).index("by_collection_document", ["collection", "documentId"]).index("by_seq", ["collection", "seq"]),
+	snapshots: defineTable({
+		collection: v.string(),
+		documentId: v.string(),
+		snapshotBytes: v.bytes(),
+		stateVector: v.bytes(),
+		snapshotSeq: v.number(),
+		createdAt: v.number()
+	}).index("by_document", ["collection", "documentId"]),
+	peers: defineTable({
+		collection: v.string(),
+		peerId: v.string(),
+		lastSyncedSeq: v.number(),
+		lastSeenAt: v.number()
+	}).index("by_collection", ["collection"]).index("by_collection_peer", ["collection", "peerId"])
 });
-export { schema as default };
+
+//#endregion
+export { schema_default as default };

package/dist/component/shared/types.d.ts

@@ -0,0 +1,9 @@
+//#region src/shared/types.d.ts
+
+/** Operation type for streaming changes */
+declare enum OperationType {
+  Delta = "delta",
+  Snapshot = "snapshot",
+}
+//#endregion
+export { OperationType };

package/dist/component/shared/types.js

@@ -0,0 +1,15 @@
+//#region src/shared/types.ts
+/** Operation type for streaming changes */
+let OperationType = /* @__PURE__ */ function(OperationType$1) {
+	OperationType$1["Delta"] = "delta";
+	OperationType$1["Snapshot"] = "snapshot";
+	return OperationType$1;
+}({});
+const SIZE_MULTIPLIERS = {
+	kb: 1024,
+	mb: 1024 ** 2,
+	gb: 1024 ** 3
+};
+
+//#endregion
+export { OperationType };

package/dist/server/index.d.ts

@@ -1,14 +1,135 @@
-export { replicate } from '$/server/builder.js';
-export type { ReplicateConfig } from '$/server/builder.js';
-import { table } from '$/server/schema.js';
-export declare const schema: {
-    readonly table: typeof table;
-    readonly prose: () => import("convex/values").VObject<{
-        content?: any[] | undefined;
-        type: "doc";
-    }, {
-        type: import("convex/values").VLiteral<"doc", "required">;
-        content: import("convex/values").VArray<any[] | undefined, import("convex/values").VAny<any, "required", string>, "optional">;
-    }, "required", "type" | "content">;
+import * as convex_values0 from "convex/values";
+import * as convex_server0 from "convex/server";
+import { GenericDataModel, GenericMutationCtx, GenericQueryCtx } from "convex/server";
+
+//#region src/shared/types.d.ts
+
+type SizeUnit = "kb" | "mb" | "gb";
+type Size = `${number}${SizeUnit}`;
+type DurationUnit = "m" | "h" | "d";
+type Duration = `${number}${DurationUnit}`;
+interface CompactionConfig {
+  sizeThreshold: Size;
+  peerTimeout: Duration;
+}
+//#endregion
+//#region src/server/builder.d.ts
+/**
+ * Configuration for replicate handlers (without component - used with factory pattern).
+ */
+interface ReplicateConfig<T extends object> {
+  collection: string;
+  compaction?: Partial<CompactionConfig>;
+  hooks?: {
+    evalRead?: (ctx: GenericQueryCtx<GenericDataModel>, collection: string) => void | Promise<void>;
+    evalWrite?: (ctx: GenericMutationCtx<GenericDataModel>, doc: T) => void | Promise<void>;
+    evalRemove?: (ctx: GenericMutationCtx<GenericDataModel>, docId: string) => void | Promise<void>;
+    evalMark?: (ctx: GenericMutationCtx<GenericDataModel>, peerId: string) => void | Promise<void>;
+    evalCompact?: (ctx: GenericMutationCtx<GenericDataModel>, documentId: string) => void | Promise<void>;
+    onStream?: (ctx: GenericQueryCtx<GenericDataModel>, result: any) => void | Promise<void>;
+    onInsert?: (ctx: GenericMutationCtx<GenericDataModel>, doc: T) => void | Promise<void>;
+    onUpdate?: (ctx: GenericMutationCtx<GenericDataModel>, doc: T) => void | Promise<void>;
+    onRemove?: (ctx: GenericMutationCtx<GenericDataModel>, docId: string) => void | Promise<void>;
+    transform?: (docs: T[]) => T[] | Promise<T[]>;
+  };
+}
+/**
+ * Create a replicate function bound to your component. Call this once in your
+ * convex/replicate.ts file, then use the returned function for all collections.
+ *
+ * @example
+ * ```typescript
+ * // convex/replicate.ts (create once)
+ * import { replicate } from '@trestleinc/replicate/server';
+ * import { components } from './_generated/api';
+ *
+ * export const tasks = replicate(components.replicate)<Task>({ collection: 'tasks' });
+ *
+ * // Or bind once and reuse:
+ * const r = replicate(components.replicate);
+ * export const tasks = r<Task>({ collection: 'tasks' });
+ * export const notebooks = r<Notebook>({ collection: 'notebooks' });
+ * ```
+ */
+declare function replicate(component: any): <T extends object>(config: ReplicateConfig<T>) => {
+  __collection: string;
+  stream: convex_server0.RegisteredQuery<"public", {
+    limit?: number | undefined;
+    sizeThreshold?: number | undefined;
+    cursor: number;
+  }, Promise<any>>;
+  material: convex_server0.RegisteredQuery<"public", {}, Promise<{
+    documents: T[];
+    cursor?: number;
+    count: number;
+    crdtBytes?: ArrayBuffer;
+  }>>;
+  recovery: convex_server0.RegisteredQuery<"public", {
+    clientStateVector: ArrayBuffer;
+  }, Promise<any>>;
+  insert: convex_server0.RegisteredMutation<"public", {
+    documentId: string;
+    crdtBytes: ArrayBuffer;
+    materializedDoc: any;
+  }, Promise<{
+    success: boolean;
+    seq: any;
+  }>>;
+  update: convex_server0.RegisteredMutation<"public", {
+    documentId: string;
+    crdtBytes: ArrayBuffer;
+    materializedDoc: any;
+  }, Promise<{
+    success: boolean;
+    seq: any;
+  }>>;
+  remove: convex_server0.RegisteredMutation<"public", {
+    documentId: string;
+    crdtBytes: ArrayBuffer;
+  }, Promise<{
+    success: boolean;
+    seq: any;
+  }>>;
+  mark: convex_server0.RegisteredMutation<"public", {
+    peerId: string;
+    syncedSeq: number;
+  }, Promise<null>>;
+  compact: convex_server0.RegisteredMutation<"public", {
+    peerTimeout?: number | undefined;
+    documentId: string;
+    snapshotBytes: ArrayBuffer;
+    stateVector: ArrayBuffer;
+  }, Promise<any>>;
 };
-export type { ReplicationFields } from '$/server/schema.js';
+//#endregion
+//#region src/server/schema.d.ts
+/**
+ * Define a table with automatic timestamp field for replication.
+ * All replicated tables must have an `id` field and define a `by_doc_id` index.
+ *
+ * @example
+ * ```typescript
+ * // convex/schema.ts
+ * export default defineSchema({
+ *   tasks: table(
+ *     { id: v.string(), text: v.string(), isCompleted: v.boolean() },
+ *     (t) => t.index('by_doc_id', ['id']).index('by_completed', ['isCompleted'])
+ *   ),
+ * });
+ * ```
+ */
+declare function table(userFields: Record<string, any>, applyIndexes?: (table: any) => any): any;
+//#endregion
+//#region src/server/index.d.ts
+declare const schema: {
+  readonly table: typeof table;
+  readonly prose: () => convex_values0.VObject<{
+    content?: any[] | undefined;
+    type: "doc";
+  }, {
+    type: convex_values0.VLiteral<"doc", "required">;
+    content: convex_values0.VArray<any[] | undefined, convex_values0.VAny<any, "required", string>, "optional">;
+  }, "required", "type" | "content">;
+};
+//#endregion
+export { type ReplicateConfig, replicate, schema };