@trestleinc/replicate 0.1.0 → 1.1.0

package/src/component/_generated/component.ts

@@ -0,0 +1,103 @@
+/* eslint-disable */
+/**
+ * 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> =
+  {
+    public: {
+      deleteDocument: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          collection: string;
+          crdtBytes: ArrayBuffer;
+          documentId: string;
+          threshold?: number;
+          version: number;
+        },
+        { compacted?: boolean; success: boolean },
+        Name
+      >;
+      getInitialState: FunctionReference<
+        "query",
+        "internal",
+        { collection: string },
+        { checkpoint: { lastModified: number }; crdtBytes: ArrayBuffer } | null,
+        Name
+      >;
+      insertDocument: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          collection: string;
+          crdtBytes: ArrayBuffer;
+          documentId: string;
+          threshold?: number;
+          version: number;
+        },
+        { compacted?: boolean; success: boolean },
+        Name
+      >;
+      recovery: FunctionReference<
+        "query",
+        "internal",
+        { clientStateVector: ArrayBuffer; collection: string },
+        { diff?: ArrayBuffer; serverStateVector: ArrayBuffer },
+        Name
+      >;
+      stream: FunctionReference<
+        "query",
+        "internal",
+        {
+          checkpoint: { lastModified: number };
+          collection: string;
+          limit?: number;
+          vector?: ArrayBuffer;
+        },
+        {
+          changes: Array<{
+            crdtBytes: ArrayBuffer;
+            documentId?: string;
+            operationType: string;
+            timestamp: number;
+            version: number;
+          }>;
+          checkpoint: { lastModified: number };
+          hasMore: boolean;
+        },
+        Name
+      >;
+      updateDocument: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          collection: string;
+          crdtBytes: ArrayBuffer;
+          documentId: string;
+          threshold?: number;
+          version: number;
+        },
+        { compacted?: boolean; success: boolean },
+        Name
+      >;
+    };
+  };

package/src/component/_generated/{dataModel.d.ts → dataModel.ts}

@@ -38,7 +38,7 @@ export type Doc<TableName extends TableNames> = DocumentByName<
  * 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(id)` in query and mutation functions.
+ * 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.

package/src/component/_generated/server.ts

@@ -0,0 +1,161 @@
+/* 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 type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} 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 const query: QueryBuilder<DataModel, "public"> = 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: QueryBuilder<DataModel, "internal"> =
+  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: MutationBuilder<DataModel, "public"> = 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: MutationBuilder<DataModel, "internal"> =
+  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: ActionBuilder<DataModel, "public"> = 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: ActionBuilder<DataModel, "internal"> =
+  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: HttpActionBuilder = httpActionGeneric;
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
+
+/**
+ * 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/src/component/convex.config.ts

@@ -1,3 +1,5 @@
 import { defineComponent } from 'convex/server';
 
-export default defineComponent('replicate');
+const component = defineComponent('replicate');
+
+export default component;

package/src/component/logger.ts

@@ -0,0 +1,36 @@
+interface Logger {
+  debug(message: string, context?: Record<string, any>): void;
+  info(message: string, context?: Record<string, any>): void;
+  warn(message: string, context?: Record<string, any>): void;
+  error(message: string, context?: Record<string, any>): void;
+}
+
+class ComponentLogger implements Logger {
+  constructor(private category: string[]) {}
+
+  private format(level: string, message: string, context?: Record<string, any>): string {
+    const prefix = `[${this.category.join(':')}]`;
+    const contextStr = context ? ` ${JSON.stringify(context)}` : '';
+    return `${prefix} ${level}: ${message}${contextStr}`;
+  }
+
+  debug(message: string, context?: Record<string, any>): void {
+    console.log(this.format('DEBUG', message, context));
+  }
+
+  info(message: string, context?: Record<string, any>): void {
+    console.log(this.format('INFO', message, context));
+  }
+
+  warn(message: string, context?: Record<string, any>): void {
+    console.warn(this.format('WARN', message, context));
+  }
+
+  error(message: string, context?: Record<string, any>): void {
+    console.error(this.format('ERROR', message, context));
+  }
+}
+
+export function getLogger(category: string[]): Logger {
+  return new ComponentLogger(['component', ...category]);
+}