cosveti-sync 0.0.1

package/dist/client/index.js

@@ -0,0 +1,238 @@
+import { mutationGeneric, queryGeneric } from 'convex/server';
+import { v } from 'convex/values';
+import { vClientId } from '../component/schema.js';
+import { Schema, Node } from '@tiptap/pm/model';
+import { Step, Transform } from '@tiptap/pm/transform';
+export class TiptapSyncSvelte {
+    component;
+    /**
+     * Backend API for the ProsemirrorSync component.
+     * Responsible for exposing the `sync` API to the client, and having
+     * convenience methods for interacting with the component from the backend.
+     *
+     * Typically used like:
+     *
+     * ```ts
+     * const prosemirrorSync = new ProsemirrorSync(components.prosemirrorSync);
+     * export const {
+     * ... // see {@link syncApi} docstring for details
+     * } = prosemirrorSync.syncApi({...});
+     * ```
+     *
+     * @param component - Generally `components.prosemirrorSync` from
+     * `./_generated/api` once you've configured it in `convex.config.ts`.
+     */
+    constructor(component) {
+        this.component = component;
+    }
+    /**
+     * Create a new document with the given ID and content.
+     *
+     * @param ctx - A Convex mutation context.
+     * @param id - The document ID.
+     * @param content - The document content. Should be ProseMirror JSON.
+     * @returns A promise that resolves when the document is created.
+     */
+    create(ctx, id, content) {
+        return ctx.runMutation(this.component.lib.submitSnapshot, {
+            id,
+            version: 1,
+            content: JSON.stringify(content)
+        });
+    }
+    /**
+     * Get the latest document version and content.
+     *
+     * @param ctx - A Convex mutation context.
+     * @param id - The document ID.
+     * @param schema - Your ProseMirror schema.
+     *   For Tiptap, use `getSchema(extensions)`.
+     *   For BlockNote, use `editor.pmSchema`.
+     * @returns The latest ProseMirror doc (Node) and version.
+     */
+    async getDoc(ctx, id, schema) {
+        const { transform, version } = await getLatestVersion(ctx, this.component, id, schema);
+        return {
+            version,
+            doc: transform.doc
+        };
+    }
+    /**
+     * Transform the document by applying the given function to the document.
+     *
+     * This will keep applying the function until the document is synced,
+     * so ensure that the function is idempotent (can be applied multiple times).
+     *
+     * e.g.
+     * ```ts
+     * import { getSchema } from "@tiptap/core";
+     * import { Transform } from "@tiptap/pm/transform";
+     *
+     * const schema = getSchema(extensions);
+     * await prosemirrorSync.transform(ctx, id, schema, (doc) => {
+     *   const tr = new Transform(doc);
+     *   tr.insert(0, schema.text("Hello world"));
+     *   return tr;
+     * });
+     * ```
+     *
+     * @param ctx - A Convex mutation context.
+     * @param id - The document ID.
+     * @param schema - The document schema.
+     * @param fn - A function that takes the document and returns a Transform
+     *   or null if no changes are needed.
+     * @returns A promise that resolves with the transformed document.
+     */
+    async transform(ctx, id, schema, fn, opts) {
+        const { transform: serverVersion, version: initialVersion } = await getLatestVersion(ctx, this.component, id, schema);
+        let version = initialVersion;
+        while (true) {
+            const tr = await fn(serverVersion.doc, version);
+            if (tr === null)
+                return serverVersion.doc;
+            const result = await ctx.runMutation(this.component.lib.submitSteps, {
+                id,
+                version,
+                clientId: opts?.clientId ?? 'transform',
+                steps: tr.steps.map((step) => JSON.stringify(step.toJSON()))
+            });
+            if (result.status === 'synced') {
+                await ctx.runMutation(this.component.lib.submitSnapshot, {
+                    id,
+                    version: version + tr.steps.length,
+                    content: JSON.stringify(tr.doc.toJSON())
+                });
+                return tr.doc;
+            }
+            for (const step of result.steps) {
+                serverVersion.step(Step.fromJSON(schema, JSON.parse(step)));
+            }
+            version += result.steps.length;
+        }
+    }
+    /**
+     * Expose the sync API to the client for use with the `useTiptapSync` hook.
+     * If you export these in `convex/prosemirror.ts`, pass `api.prosemirror`
+     * to the `useTiptapSync` hook.
+     *
+     * It allows you to define optional read and write permissions, along with
+     * a callback when new snapshots are available.
+     *
+     * You can pass the optional type argument `<DataModel>` to have the `ctx`
+     * parameter specific to your tables.
+     *
+     * ```ts
+     * import { DataModel } from "./convex/_generated/dataModel";
+     * // ...
+     * export const { ... } = prosemirrorSync.syncApi<DataModel>({...});
+     * ```
+     *
+     * To define just one function to use for both, you can define it like this:
+     * ```ts
+     * async function checkPermissions(ctx: QueryCtx, id: string) {
+     *   const user = await getAuthUser(ctx);
+     *   if (!user || !(await canUserAccessDocument(user, id))) {
+     *     throw new Error("Unauthorized");
+     *   }
+     * }
+     * ```
+     * @param opts - Optional callbacks.
+     * @returns functions to export, so the `useTiptapSync` hook can use them.
+     */
+    syncApi(opts) {
+        const id = v.string();
+        return {
+            getSnapshot: queryGeneric({
+                args: {
+                    id,
+                    version: v.optional(v.number())
+                },
+                returns: v.union(v.object({
+                    content: v.null(),
+                    version: v.null()
+                }), v.object({
+                    content: v.string(),
+                    version: v.number()
+                })),
+                handler: async (ctx, args) => {
+                    if (opts?.checkRead) {
+                        await opts.checkRead(ctx, args.id);
+                    }
+                    return ctx.runQuery(this.component.lib.getSnapshot, args);
+                }
+            }),
+            submitSnapshot: mutationGeneric({
+                args: {
+                    id,
+                    version: v.number(),
+                    content: v.string()
+                },
+                returns: v.null(),
+                handler: async (ctx, args) => {
+                    if (opts?.checkWrite) {
+                        await opts.checkWrite(ctx, args.id);
+                    }
+                    if (opts?.onSnapshot) {
+                        await opts.onSnapshot(ctx, args.id, args.content, args.version);
+                    }
+                    await ctx.runMutation(this.component.lib.submitSnapshot, {
+                        ...args,
+                        pruneSnapshots: opts?.pruneSnapshots
+                    });
+                }
+            }),
+            latestVersion: queryGeneric({
+                args: { id },
+                returns: v.union(v.null(), v.number()),
+                handler: async (ctx, args) => {
+                    if (opts?.checkRead) {
+                        await opts.checkRead(ctx, args.id);
+                    }
+                    return ctx.runQuery(this.component.lib.latestVersion, args);
+                }
+            }),
+            getSteps: queryGeneric({
+                args: {
+                    id,
+                    version: v.number()
+                },
+                handler: async (ctx, args) => {
+                    if (opts?.checkRead) {
+                        await opts.checkRead(ctx, args.id);
+                    }
+                    return ctx.runQuery(this.component.lib.getSteps, args);
+                }
+            }),
+            submitSteps: mutationGeneric({
+                args: {
+                    id,
+                    version: v.number(),
+                    clientId: vClientId,
+                    steps: v.array(v.string())
+                },
+                handler: async (ctx, args) => {
+                    if (opts?.checkWrite) {
+                        await opts.checkWrite(ctx, args.id);
+                    }
+                    return ctx.runMutation(this.component.lib.submitSteps, args);
+                }
+            })
+        };
+    }
+}
+async function getLatestVersion(ctx, component, id, schema) {
+    const snapshot = await ctx.runQuery(component.lib.getSnapshot, { id });
+    if (!snapshot.content) {
+        throw new Error('Document not found');
+    }
+    const content = JSON.parse(snapshot.content);
+    const transform = new Transform(schema.nodeFromJSON(content));
+    const { steps, version } = await ctx.runQuery(component.lib.getSteps, {
+        id,
+        version: snapshot.version
+    });
+    for (const step of steps) {
+        transform.step(Step.fromJSON(schema, JSON.parse(step)));
+    }
+    return { transform, version };
+}

package/dist/component/_generated/api.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as lib from "../lib.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    lib: typeof lib;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {};
+export {};

package/dist/component/_generated/api.js

@@ -0,0 +1,30 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal = anyApi;
+export const components = componentsGeneric();

package/dist/component/_generated/component.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { FunctionReference } from "convex/server";
+/**
+ * A utility for referencing a Convex component's exposed API.
+ *
+ * Useful when expecting a parameter like `components.myComponent`.
+ * Usage:
+ * ```ts
+ * async function myFunction(ctx: QueryCtx, component: ComponentApi) {
+ *   return ctx.runQuery(component.someFile.someQuery, { ...args });
+ * }
+ * ```
+ */
+export type ComponentApi<Name extends string | undefined = string | undefined> = {
+    lib: {
+        deleteDocument: FunctionReference<"mutation", "internal", {
+            id: string;
+        }, null, Name>;
+        deleteSnapshots: FunctionReference<"mutation", "internal", {
+            afterVersion?: number;
+            beforeVersion?: number;
+            id: string;
+        }, null, Name>;
+        deleteSteps: FunctionReference<"mutation", "internal", {
+            afterVersion?: number;
+            beforeTs: number;
+            deleteNewerThanLatestSnapshot?: boolean;
+            id: string;
+        }, null, Name>;
+        getSnapshot: FunctionReference<"query", "internal", {
+            id: string;
+            version?: number;
+        }, {
+            content: null;
+            version: null;
+        } | {
+            content: string;
+            version: number;
+        }, Name>;
+        getSteps: FunctionReference<"query", "internal", {
+            id: string;
+            version: number;
+        }, {
+            clientIds: Array<string | number>;
+            steps: Array<string>;
+            version: number;
+        }, Name>;
+        latestVersion: FunctionReference<"query", "internal", {
+            id: string;
+        }, null | number, Name>;
+        submitSnapshot: FunctionReference<"mutation", "internal", {
+            content: string;
+            id: string;
+            pruneSnapshots?: boolean;
+            version: number;
+        }, null, Name>;
+        submitSteps: FunctionReference<"mutation", "internal", {
+            clientId: string | number;
+            id: string;
+            steps: Array<string>;
+            version: number;
+        }, {
+            clientIds: Array<string | number>;
+            status: "needs-rebase";
+            steps: Array<string>;
+        } | {
+            status: "synced";
+        }, Name>;
+    };
+};

package/dist/component/_generated/component.js

@@ -0,0 +1,10 @@
+/* eslint-disable */
+/**
+ * Generated `ComponentApi` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+export {};

package/dist/component/_generated/dataModel.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { DataModelFromSchemaDefinition, DocumentByName, TableNamesInDataModel, SystemTableNames } from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<DataModel, TableName>;
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/dist/component/_generated/dataModel.js

@@ -0,0 +1,10 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import schema from "../schema.js";

package/dist/component/_generated/server.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
+import type { DataModel } from "./dataModel.js";
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/dist/component/_generated/server.js

@@ -0,0 +1,77 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { actionGeneric, httpActionGeneric, queryGeneric, mutationGeneric, internalActionGeneric, internalMutationGeneric, internalQueryGeneric, } from "convex/server";
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;

package/dist/component/convex.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("convex/server").ComponentDefinition<any>;
+export default _default;

package/dist/component/convex.config.js

@@ -0,0 +1,2 @@
+import { defineComponent } from 'convex/server';
+export default defineComponent('tiptapSyncSvelte');