convex-supermemory 0.0.1

package/dist/component/schema.d.ts

@@ -0,0 +1,56 @@
+declare const _default: import("convex/server").SchemaDefinition<{
+    memories: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        metadata?: string | undefined;
+        forgetAfter?: number | undefined;
+        forgetReason?: string | undefined;
+        memoryId: string;
+        containerTag: string;
+        content: string;
+        isStatic: boolean;
+        forgotten: boolean;
+        createdAt: number;
+        updatedAt: number;
+    }, {
+        memoryId: import("convex/values").VString<string, "required">;
+        containerTag: import("convex/values").VString<string, "required">;
+        content: import("convex/values").VString<string, "required">;
+        isStatic: import("convex/values").VBoolean<boolean, "required">;
+        metadata: import("convex/values").VString<string | undefined, "optional">;
+        forgetAfter: import("convex/values").VFloat64<number | undefined, "optional">;
+        forgetReason: import("convex/values").VString<string | undefined, "optional">;
+        forgotten: import("convex/values").VBoolean<boolean, "required">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "memoryId" | "containerTag" | "content" | "metadata" | "forgetAfter" | "forgetReason" | "isStatic" | "forgotten" | "createdAt" | "updatedAt">, {
+        by_memoryId: ["memoryId", "_creationTime"];
+        by_containerTag: ["containerTag", "_creationTime"];
+    }, {}, {}>;
+    documents: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        content?: string | undefined;
+        customId?: string | undefined;
+        metadata?: string | undefined;
+        summary?: string | undefined;
+        title?: string | undefined;
+        documentId: string;
+        containerTag: string;
+        status: "unknown" | "queued" | "extracting" | "chunking" | "embedding" | "indexing" | "done" | "failed";
+        createdAt: number;
+        updatedAt: number;
+    }, {
+        documentId: import("convex/values").VString<string, "required">;
+        containerTag: import("convex/values").VString<string, "required">;
+        content: import("convex/values").VString<string | undefined, "optional">;
+        customId: import("convex/values").VString<string | undefined, "optional">;
+        metadata: import("convex/values").VString<string | undefined, "optional">;
+        status: import("convex/values").VUnion<"unknown" | "queued" | "extracting" | "chunking" | "embedding" | "indexing" | "done" | "failed", [import("convex/values").VLiteral<"unknown", "required">, import("convex/values").VLiteral<"queued", "required">, import("convex/values").VLiteral<"extracting", "required">, import("convex/values").VLiteral<"chunking", "required">, import("convex/values").VLiteral<"embedding", "required">, import("convex/values").VLiteral<"indexing", "required">, import("convex/values").VLiteral<"done", "required">, import("convex/values").VLiteral<"failed", "required">], "required", never>;
+        title: import("convex/values").VString<string | undefined, "optional">;
+        summary: import("convex/values").VString<string | undefined, "optional">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "documentId" | "containerTag" | "content" | "customId" | "metadata" | "status" | "summary" | "title" | "createdAt" | "updatedAt">, {
+        by_documentId: ["documentId", "_creationTime"];
+        by_containerTag: ["containerTag", "_creationTime"];
+    }, {}, {}>;
+}, true>;
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/dist/component/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAuCG"}

package/dist/component/schema.js

@@ -0,0 +1,33 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+export default defineSchema({
+    memories: defineTable({
+        memoryId: v.string(),
+        containerTag: v.string(),
+        content: v.string(),
+        isStatic: v.boolean(),
+        metadata: v.optional(v.string()),
+        forgetAfter: v.optional(v.number()),
+        forgetReason: v.optional(v.string()),
+        forgotten: v.boolean(),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_memoryId", ["memoryId"])
+        .index("by_containerTag", ["containerTag"]),
+    documents: defineTable({
+        documentId: v.string(),
+        containerTag: v.string(),
+        content: v.optional(v.string()),
+        customId: v.optional(v.string()),
+        metadata: v.optional(v.string()),
+        status: v.union(v.literal("unknown"), v.literal("queued"), v.literal("extracting"), v.literal("chunking"), v.literal("embedding"), v.literal("indexing"), v.literal("done"), v.literal("failed")),
+        title: v.optional(v.string()),
+        summary: v.optional(v.string()),
+        createdAt: v.number(),
+        updatedAt: v.number(),
+    })
+        .index("by_documentId", ["documentId"])
+        .index("by_containerTag", ["containerTag"]),
+});
+//# sourceMappingURL=schema.js.map

package/dist/component/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAElC,eAAe,YAAY,CAAC;IAC1B,QAAQ,EAAE,WAAW,CAAC;QACpB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;QACpB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;QACxB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;QACnB,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE;QACrB,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAChC,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACnC,YAAY,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QACpC,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;QACtB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;QACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;KACtB,CAAC;SACC,KAAK,CAAC,aAAa,EAAE,CAAC,UAAU,CAAC,CAAC;SAClC,KAAK,CAAC,iBAAiB,EAAE,CAAC,cAAc,CAAC,CAAC;IAE7C,SAAS,EAAE,WAAW,CAAC;QACrB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;QACtB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;QACxB,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAC/B,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAChC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,EAAE,CAAC,CAAC,KAAK,CACb,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EACpB,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EACnB,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EACvB,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EACrB,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EACtB,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EACrB,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EACjB,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CACpB;QACD,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAC7B,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;QAC/B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;QACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;KACtB,CAAC;SACC,KAAK,CAAC,eAAe,EAAE,CAAC,YAAY,CAAC,CAAC;SACtC,KAAK,CAAC,iBAAiB,EAAE,CAAC,cAAc,CAAC,CAAC;CAC9C,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "convex-supermemory",
+  "description": "Give your Convex app long-term, semantically searchable memory with Supermemory. Reactive local memory and document state, direct REST integration.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sholajegede/convex-supermemory.git"
+  },
+  "homepage": "https://github.com/sholajegede/convex-supermemory#readme",
+  "bugs": {
+    "url": "https://github.com/sholajegede/convex-supermemory/issues"
+  },
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "keywords": [
+    "convex",
+    "component",
+    "supermemory",
+    "memory",
+    "rag",
+    "ai",
+    "agents",
+    "search"
+  ],
+  "type": "module",
+  "scripts": {
+    "dev": "run-p -r 'dev:*'",
+    "dev:backend": "convex dev --typecheck-components",
+    "dev:frontend": "cd example && vite --clearScreen false",
+    "dev:build": "chokidar 'tsconfig*.json' 'src/**/*.ts' -i '**/*.test.ts' -c 'npm run build:codegen' --initial",
+    "predev": "path-exists .env.local dist || (npm run build && convex dev --once)",
+    "build": "tsc --project ./tsconfig.build.json",
+    "build:codegen": "npx convex codegen --component-dir ./src/component && npm run build",
+    "build:clean": "rm -rf dist *.tsbuildinfo && npm run build:codegen",
+    "typecheck": "tsc --noEmit && tsc -p example && tsc -p example/convex",
+    "lint": "eslint .",
+    "all": "run-p -r 'dev:*' 'test:watch'",
+    "test": "vitest run --typecheck",
+    "test:watch": "vitest --typecheck --clearScreen false",
+    "test:debug": "vitest --inspect-brk --no-file-parallelism",
+    "test:coverage": "vitest run --coverage --coverage.reporter=text",
+    "preversion": "npm install --legacy-peer-deps && npm run build:clean && run-p test lint typecheck",
+    "prepublishOnly": "npm whoami || npm login",
+    "alpha": "npm version prerelease --preid alpha && npm publish --tag alpha && git push --follow-tags",
+    "release": "npm version patch && npm publish && git push --follow-tags",
+    "version": "vim -c 'normal o' -c 'normal o## '$npm_package_version CHANGELOG.md && prettier -w CHANGELOG.md && git add CHANGELOG.md"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/client/index.d.ts",
+      "default": "./dist/client/index.js"
+    },
+    "./test": "./src/test.ts",
+    "./_generated/component.js": {
+      "types": "./dist/component/_generated/component.d.ts"
+    },
+    "./_generated/component": {
+      "types": "./dist/component/_generated/component.d.ts"
+    },
+    "./convex.config.js": {
+      "types": "./dist/component/convex.config.d.ts",
+      "default": "./dist/component/convex.config.js"
+    },
+    "./convex.config": {
+      "types": "./dist/component/convex.config.d.ts",
+      "default": "./dist/component/convex.config.js"
+    }
+  },
+  "peerDependencies": {
+    "convex": "^1.34.1"
+  },
+  "devDependencies": {
+    "@convex-dev/eslint-plugin": "^1.2.0",
+    "@edge-runtime/vm": "^5.0.0",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "9.39.4",
+    "@types/node": "^24.12.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.2.0",
+    "chokidar-cli": "3.0.0",
+    "convex": "1.45.0",
+    "convex-test": "0.0.41",
+    "eslint": "9.39.4",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "npm-run-all2": "8.0.4",
+    "path-exists-cli": "2.0.0",
+    "pkg-pr-new": "^0.0.66",
+    "prettier": "3.8.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.57.1",
+    "vite": "7.3.1",
+    "vitest": "4.1.0"
+  },
+  "types": "./dist/client/index.d.ts",
+  "module": "./dist/client/index.js"
+}

package/src/client/_generated/_ignore.ts

@@ -0,0 +1 @@
+// This is only here so convex-test can detect a _generated folder

package/src/client/index.ts

@@ -0,0 +1,289 @@
+import type { GenericActionCtx, GenericDataModel } from "convex/server";
+import type { ComponentApi } from "../component/_generated/component.js";
+
+const SUPERMEMORY_API_BASE = "https://api.supermemory.ai";
+
+export type SupermemoryOptions = {
+  apiKey: string;
+  baseUrl?: string;
+};
+
+export type AddMemoryArgs = {
+  containerTag: string;
+  content: string;
+  isStatic?: boolean;
+  metadata?: Record<string, unknown>;
+  forgetAfter?: number;
+  forgetReason?: string;
+};
+
+export type AddDocumentArgs = {
+  containerTag: string;
+  content: string;
+  customId?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type SearchArgs = {
+  containerTag: string;
+  query: string;
+  limit?: number;
+  rerank?: boolean;
+  includeFullDocs?: boolean;
+};
+
+export type SearchResult = {
+  documentId: string;
+  title: string | null;
+  score: number;
+  summary: string | null;
+  content: string | null;
+  chunks: Array<{ content: string; score: number; position: number; isRelevant: boolean }>;
+};
+
+export type SearchResponse = {
+  results: SearchResult[];
+  total: number;
+  timing?: number; // ms, when Supermemory reports it
+};
+
+export class Supermemory {
+  constructor(
+    private component: ComponentApi,
+    private options: SupermemoryOptions,
+  ) {}
+
+  private baseUrl(): string {
+    return this.options.baseUrl ?? SUPERMEMORY_API_BASE;
+  }
+
+  private headers(): Record<string, string> {
+    return {
+      Authorization: `Bearer ${this.options.apiKey}`,
+      "Content-Type": "application/json",
+    };
+  }
+
+  /** Store a single fact/memory directly (fast path — no chunking pipeline). */
+  async addMemory(
+    ctx: GenericActionCtx<GenericDataModel>,
+    args: AddMemoryArgs,
+  ): Promise<{ memoryId: string }> {
+    const res = await fetch(`${this.baseUrl()}/v4/memories`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({
+        containerTag: args.containerTag,
+        memories: [
+          {
+            content: args.content,
+            isStatic: args.isStatic ?? false,
+            metadata: args.metadata,
+            forgetAfter: args.forgetAfter
+              ? new Date(args.forgetAfter).toISOString()
+              : undefined,
+            forgetReason: args.forgetReason,
+          },
+        ],
+      }),
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to add Supermemory memory: ${res.status} ${await res.text()}`);
+    }
+    const json = (await res.json()) as {
+      memories: Array<{ id: string; memory: string; isStatic: boolean; createdAt: string }>;
+    };
+    const memory = json.memories[0];
+
+    await ctx.runMutation(this.component.lib.recordMemory, {
+      memoryId: memory.id,
+      containerTag: args.containerTag,
+      content: args.content,
+      isStatic: args.isStatic ?? false,
+      metadata: args.metadata ? JSON.stringify(args.metadata) : undefined,
+      forgetAfter: args.forgetAfter,
+      forgetReason: args.forgetReason,
+    });
+
+    return { memoryId: memory.id };
+  }
+
+  /** Mark a memory as forgotten. Supermemory may forget it asynchronously. */
+  async forgetMemory(
+    ctx: GenericActionCtx<GenericDataModel>,
+    args: { containerTag: string; memoryId: string },
+  ): Promise<{ forgotten: boolean }> {
+    const res = await fetch(`${this.baseUrl()}/v4/memories`, {
+      method: "DELETE",
+      headers: this.headers(),
+      // containerTag is required by Supermemory to scope the delete —
+      // omitting it makes this a 400, not a silent no-op.
+      body: JSON.stringify({ id: args.memoryId, containerTag: args.containerTag }),
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to forget Supermemory memory: ${res.status} ${await res.text()}`);
+    }
+    const json = (await res.json()) as { id: string; forgotten: boolean };
+
+    if (json.forgotten) {
+      await ctx.runMutation(this.component.lib.markMemoryForgotten, { memoryId: args.memoryId });
+    }
+
+    return { forgotten: json.forgotten };
+  }
+
+  /**
+   * Ingest a larger piece of content (a document, page, or conversation) through
+   * Supermemory's extraction/chunking pipeline. Use `getDocument`/`refreshDocument`
+   * to poll processing status.
+   */
+  async addDocument(
+    ctx: GenericActionCtx<GenericDataModel>,
+    args: AddDocumentArgs,
+  ): Promise<{ documentId: string; status: string }> {
+    const res = await fetch(`${this.baseUrl()}/v3/documents`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({
+        content: args.content,
+        containerTag: args.containerTag,
+        customId: args.customId,
+        metadata: args.metadata,
+      }),
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to add Supermemory document: ${res.status} ${await res.text()}`);
+    }
+    const json = (await res.json()) as { id: string; status: string };
+
+    await ctx.runMutation(this.component.lib.recordDocument, {
+      documentId: json.id,
+      containerTag: args.containerTag,
+      content: args.content,
+      customId: args.customId,
+      metadata: args.metadata ? JSON.stringify(args.metadata) : undefined,
+      status: (json.status as
+        | "unknown"
+        | "queued"
+        | "extracting"
+        | "chunking"
+        | "embedding"
+        | "indexing"
+        | "done"
+        | "failed") ?? "queued",
+    });
+
+    return { documentId: json.id, status: json.status };
+  }
+
+  /** Refresh a document's processing status, title, and summary from Supermemory. */
+  async refreshDocument(
+    ctx: GenericActionCtx<GenericDataModel>,
+    args: { documentId: string },
+  ): Promise<void> {
+    const res = await fetch(`${this.baseUrl()}/v3/documents/${encodeURIComponent(args.documentId)}`, {
+      headers: this.headers(),
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to fetch Supermemory document: ${res.status} ${await res.text()}`);
+    }
+    const json = (await res.json()) as {
+      id: string;
+      status: string;
+      title: string | null;
+      summary: string | null;
+      content: string | null;
+      metadata: Record<string, unknown> | null;
+    };
+
+    const existing = await ctx.runQuery(this.component.lib.getDocument, { documentId: args.documentId });
+
+    await ctx.runMutation(this.component.lib.recordDocument, {
+      documentId: json.id,
+      containerTag: existing?.containerTag ?? "",
+      content: json.content ?? existing?.content,
+      customId: existing?.customId,
+      metadata: json.metadata ? JSON.stringify(json.metadata) : existing?.metadata,
+      status: json.status as
+        | "unknown"
+        | "queued"
+        | "extracting"
+        | "chunking"
+        | "embedding"
+        | "indexing"
+        | "done"
+        | "failed",
+      title: json.title ?? undefined,
+      summary: json.summary ?? undefined,
+    });
+  }
+
+  async deleteDocument(
+    ctx: GenericActionCtx<GenericDataModel>,
+    args: { documentId: string },
+  ): Promise<void> {
+    const res = await fetch(`${this.baseUrl()}/v3/documents/${encodeURIComponent(args.documentId)}`, {
+      method: "DELETE",
+      headers: this.headers(),
+    });
+    if (!res.ok && res.status !== 204) {
+      throw new Error(`Failed to delete Supermemory document: ${res.status} ${await res.text()}`);
+    }
+    await ctx.runMutation(this.component.lib.deleteDocument, { documentId: args.documentId });
+  }
+
+  /** Semantic search over a container's document chunks. Always live — not cached locally. */
+  async search(args: SearchArgs): Promise<SearchResponse> {
+    const res = await fetch(`${this.baseUrl()}/v3/search`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({
+        q: args.query,
+        // Supermemory's /v3/search schema documents singular `containerTag` as
+        // valid, but the only worked example in their own docs uses the plural
+        // `containerTags` array — and in practice singular reliably returns
+        // zero matches even against fully-indexed content. Use the array form.
+        containerTags: [args.containerTag],
+        limit: args.limit ?? 10,
+        rerank: args.rerank ?? false,
+        includeFullDocs: args.includeFullDocs ?? false,
+      }),
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to search Supermemory: ${res.status} ${await res.text()}`);
+    }
+    return (await res.json()) as SearchResponse;
+  }
+
+  async getMemory(ctx: RunQueryCtx, args: { memoryId: string }) {
+    return await ctx.runQuery(this.component.lib.getMemory, args);
+  }
+
+  async listMemories(ctx: RunQueryCtx, args: { containerTag: string; limit?: number }) {
+    return await ctx.runQuery(this.component.lib.listMemories, args);
+  }
+
+  async getDocument(ctx: RunQueryCtx, args: { documentId: string }) {
+    return await ctx.runQuery(this.component.lib.getDocument, args);
+  }
+
+  async listDocuments(ctx: RunQueryCtx, args: { containerTag: string; limit?: number }) {
+    return await ctx.runQuery(this.component.lib.listDocuments, args);
+  }
+
+  async getStats(ctx: RunQueryCtx) {
+    return await ctx.runQuery(this.component.lib.getStats, {});
+  }
+
+  async listRecentMemories(ctx: RunQueryCtx, args: { limit?: number } = {}) {
+    return await ctx.runQuery(this.component.lib.listRecentMemories, args);
+  }
+
+  async listRecentDocuments(ctx: RunQueryCtx, args: { limit?: number } = {}) {
+    return await ctx.runQuery(this.component.lib.listRecentDocuments, args);
+  }
+}
+
+type RunQueryCtx = {
+  runQuery: GenericActionCtx<GenericDataModel>["runQuery"];
+};

package/src/client/setup.test.ts

@@ -0,0 +1,26 @@
+/// <reference types="vite/client" />
+import { test } from "vitest";
+import { convexTest } from "convex-test";
+export const modules = import.meta.glob("./**/*.*s");
+
+import {
+  defineSchema,
+  type GenericSchema,
+  type SchemaDefinition,
+} from "convex/server";
+import { type ComponentApi } from "../component/_generated/component.js";
+import { componentsGeneric } from "convex/server";
+import { register } from "../test.js";
+
+export function initConvexTest<
+  Schema extends SchemaDefinition<GenericSchema, boolean>,
+>(schema?: Schema) {
+  const t = convexTest(schema ?? defineSchema({}), modules);
+  register(t);
+  return t;
+}
+export const components = componentsGeneric() as unknown as {
+  convexSupermemory: ComponentApi;
+};
+
+test("setup", () => {});

package/src/component/_generated/api.ts

@@ -0,0 +1,50 @@
+/* eslint-disable */
+/**
+ * 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";
+import { anyApi, componentsGeneric } from "convex/server";
+
+const fullApi: ApiFromModules<{
+  lib: typeof lib;
+}> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
+
+export const components = componentsGeneric() as unknown as {};