@memoryengine/client 0.1.0

package/dist/schemas/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../src/schemas/rpc.ts"],"names":[],"mappings":"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"}

package/dist/schemas/rpc.js

@@ -0,0 +1,137 @@
+/**
+ * RPC Contract - maps method names to input/output types
+ *
+ * This is the key to type inference: define the contract once,
+ * and both server validation and client types are derived from it.
+ */
+import { z } from "zod";
+// Auth schemas
+import { apiKeySchema, createApiKeyResultSchema, createApiKeySchema, loginResultSchema, loginSchema, principalSchema, revokeApiKeySchema, successSchema, whoamiSchema, } from "./auth";
+// Engram schemas
+import { batchCreateEngramSchema, batchCreateResultSchema, createEngramSchema, deleteEngramSchema, deleteResultSchema, engramSchema, getEngramSchema, mvEngramResultSchema, mvEngramSchema, searchEngramResultSchema, searchEngramSchema, updateEngramSchema, } from "./engram";
+// Principal schemas
+import { addRoleMemberSchema, checkTreeAccessSchema, createPrincipalSchema, deletePrincipalSchema, getPrincipalSchema, getTreeOwnerSchema, grantTreeAccessSchema, listRoleMembersSchema, listRolesForPrincipalSchema, listTreeGrantsSchema, listTreeOwnersSchema, principalDetailSchema, principalListItemSchema, principalRoleSchema, removeRoleMemberSchema, removeTreeOwnerSchema, revokeTreeAccessSchema, roleMemberSchema, setPasswordSchema, setTreeOwnerSchema, treeGrantSchema, treeOwnerSchema, } from "./principal";
+// ===== RPC Method Definition =====
+/**
+ * Define a method with its input schema and output type.
+ * The output type is specified as a generic since DB results
+ * aren't validated at runtime (trusted internal data).
+ *
+ * Uses z.input<> for input types to preserve optionality of fields
+ * with defaults (e.g., limit?: number with .default(100) stays optional
+ * for callers, but the server gets the default after parsing).
+ */
+function method(input, _output) {
+    return {
+        input,
+        _types: {},
+    };
+}
+/** For methods with no input params */
+const emptySchema = z.object({});
+// ===== Auth Methods Contract =====
+export const authMethods = {
+    "auth.login": method(loginSchema, {}),
+    "auth.whoami": method(emptySchema, {}),
+    "auth.createApiKey": method(createApiKeySchema, {}),
+    "auth.listApiKeys": method(emptySchema, {}),
+    "auth.revokeApiKey": method(revokeApiKeySchema, {}),
+};
+// ===== Principal Methods Contract =====
+export const principalMethods = {
+    "principal.list": method(emptySchema, {}),
+    "principal.get": method(getPrincipalSchema, {}),
+    "principal.create": method(createPrincipalSchema, {}),
+    "principal.delete": method(deletePrincipalSchema, {}),
+    "principal.setPassword": method(setPasswordSchema, {}),
+};
+// ===== Grant Methods Contract =====
+export const grantMethods = {
+    "grant.create": method(grantTreeAccessSchema, {}),
+    "grant.revoke": method(revokeTreeAccessSchema, {}),
+    "grant.list": method(listTreeGrantsSchema, {}),
+    "grant.check": method(checkTreeAccessSchema, {}),
+};
+// ===== Owner Methods Contract =====
+export const ownerMethods = {
+    "owner.set": method(setTreeOwnerSchema, {}),
+    "owner.remove": method(removeTreeOwnerSchema, {}),
+    "owner.get": method(getTreeOwnerSchema, {}),
+    "owner.list": method(listTreeOwnersSchema, {}),
+};
+// ===== Role Methods Contract =====
+export const roleMethods = {
+    "role.addMember": method(addRoleMemberSchema, {}),
+    "role.removeMember": method(removeRoleMemberSchema, {}),
+    "role.listMembers": method(listRoleMembersSchema, {}),
+    "role.listForPrincipal": method(listRolesForPrincipalSchema, {}),
+};
+// ===== Engram Methods Contract =====
+export const engramMethods = {
+    "engram.create": method(createEngramSchema, {}),
+    "engram.batchCreate": method(batchCreateEngramSchema, {}),
+    "engram.get": method(getEngramSchema, {}),
+    "engram.update": method(updateEngramSchema, {}),
+    "engram.delete": method(deleteEngramSchema, {}),
+    "engram.search": method(searchEngramSchema, {}),
+    "engram.mv": method(mvEngramSchema, {}),
+};
+// ===== Combined RPC Contract =====
+/** All registered RPC methods */
+export const rpcMethods = {
+    ...authMethods,
+    ...principalMethods,
+    ...grantMethods,
+    ...ownerMethods,
+    ...roleMethods,
+    ...engramMethods,
+};
+/** Get the input schema for runtime validation */
+export function getInputSchema(method) {
+    return rpcMethods[method].input;
+}
+// ===== Output Schema Map =====
+const checkAccessOutputSchema = z.object({ allowed: z.boolean() });
+/** Runtime output schemas for response validation */
+const outputSchemas = {
+    // Auth
+    "auth.login": loginResultSchema,
+    "auth.whoami": whoamiSchema,
+    "auth.createApiKey": createApiKeyResultSchema,
+    "auth.listApiKeys": z.array(apiKeySchema),
+    "auth.revokeApiKey": successSchema,
+    // Principal
+    "principal.list": z.array(principalListItemSchema),
+    "principal.get": principalDetailSchema,
+    "principal.create": principalSchema,
+    "principal.delete": successSchema,
+    "principal.setPassword": successSchema,
+    // Grant
+    "grant.create": successSchema,
+    "grant.revoke": successSchema,
+    "grant.list": z.array(treeGrantSchema),
+    "grant.check": checkAccessOutputSchema,
+    // Owner
+    "owner.set": successSchema,
+    "owner.remove": successSchema,
+    "owner.get": treeOwnerSchema.nullable(),
+    "owner.list": z.array(treeOwnerSchema),
+    // Role
+    "role.addMember": successSchema,
+    "role.removeMember": successSchema,
+    "role.listMembers": z.array(roleMemberSchema),
+    "role.listForPrincipal": z.array(principalRoleSchema),
+    // Engram
+    "engram.create": engramSchema,
+    "engram.batchCreate": batchCreateResultSchema,
+    "engram.get": engramSchema,
+    "engram.update": engramSchema,
+    "engram.delete": deleteResultSchema,
+    "engram.search": searchEngramResultSchema,
+    "engram.mv": mvEngramResultSchema,
+};
+/** Get the output schema for runtime response validation */
+export function getOutputSchema(method) {
+    return outputSchemas[method];
+}
+//# sourceMappingURL=rpc.js.map

package/dist/schemas/rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../../src/schemas/rpc.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@memoryengine/client",
+  "version": "0.1.0",
+  "description": "Client library for memory engine",
+  "type": "module",
+  "module": "src/index.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schemas": {
+      "bun": "./src/schemas/index.ts",
+      "types": "./dist/schemas/index.d.ts",
+      "import": "./dist/schemas/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,415 @@
+/**
+ * Client library for the me JSON-RPC API
+ * HTTP-based client with full type inference
+ */
+
+import {
+  getOutputSchema,
+  type RpcInput,
+  type RpcMethodName,
+  type RpcOutput,
+} from "./schemas";
+
+// ===== Namespace Types =====
+
+type EngramNamespace = {
+  create: (
+    params: RpcInput<"engram.create">,
+  ) => Promise<RpcOutput<"engram.create">>;
+  get: (params: RpcInput<"engram.get">) => Promise<RpcOutput<"engram.get">>;
+  search: (
+    params: RpcInput<"engram.search">,
+  ) => Promise<RpcOutput<"engram.search">>;
+  update: (
+    params: RpcInput<"engram.update">,
+  ) => Promise<RpcOutput<"engram.update">>;
+  delete: (
+    params: RpcInput<"engram.delete">,
+  ) => Promise<RpcOutput<"engram.delete">>;
+  batchCreate: (
+    params: RpcInput<"engram.batchCreate">,
+  ) => Promise<RpcOutput<"engram.batchCreate">>;
+  mv: (params: RpcInput<"engram.mv">) => Promise<RpcOutput<"engram.mv">>;
+};
+
+type AuthNamespace = {
+  login: (params: RpcInput<"auth.login">) => Promise<RpcOutput<"auth.login">>;
+  whoami: () => Promise<RpcOutput<"auth.whoami">>;
+  createApiKey: (
+    params: RpcInput<"auth.createApiKey">,
+  ) => Promise<RpcOutput<"auth.createApiKey">>;
+  listApiKeys: () => Promise<RpcOutput<"auth.listApiKeys">>;
+  revokeApiKey: (
+    params: RpcInput<"auth.revokeApiKey">,
+  ) => Promise<RpcOutput<"auth.revokeApiKey">>;
+};
+
+type PrincipalNamespace = {
+  list: () => Promise<RpcOutput<"principal.list">>;
+  get: (
+    params: RpcInput<"principal.get">,
+  ) => Promise<RpcOutput<"principal.get">>;
+  create: (
+    params: RpcInput<"principal.create">,
+  ) => Promise<RpcOutput<"principal.create">>;
+  delete: (
+    params: RpcInput<"principal.delete">,
+  ) => Promise<RpcOutput<"principal.delete">>;
+  setPassword: (
+    params: RpcInput<"principal.setPassword">,
+  ) => Promise<RpcOutput<"principal.setPassword">>;
+};
+
+type GrantNamespace = {
+  create: (
+    params: RpcInput<"grant.create">,
+  ) => Promise<RpcOutput<"grant.create">>;
+  revoke: (
+    params: RpcInput<"grant.revoke">,
+  ) => Promise<RpcOutput<"grant.revoke">>;
+  list: (params?: RpcInput<"grant.list">) => Promise<RpcOutput<"grant.list">>;
+  check: (params: RpcInput<"grant.check">) => Promise<RpcOutput<"grant.check">>;
+};
+
+type OwnerNamespace = {
+  set: (params: RpcInput<"owner.set">) => Promise<RpcOutput<"owner.set">>;
+  remove: (
+    params: RpcInput<"owner.remove">,
+  ) => Promise<RpcOutput<"owner.remove">>;
+  get: (params: RpcInput<"owner.get">) => Promise<RpcOutput<"owner.get">>;
+  list: (params?: RpcInput<"owner.list">) => Promise<RpcOutput<"owner.list">>;
+};
+
+type RoleNamespace = {
+  addMember: (
+    params: RpcInput<"role.addMember">,
+  ) => Promise<RpcOutput<"role.addMember">>;
+  removeMember: (
+    params: RpcInput<"role.removeMember">,
+  ) => Promise<RpcOutput<"role.removeMember">>;
+  listMembers: (
+    params: RpcInput<"role.listMembers">,
+  ) => Promise<RpcOutput<"role.listMembers">>;
+  listForPrincipal: (
+    params?: RpcInput<"role.listForPrincipal">,
+  ) => Promise<RpcOutput<"role.listForPrincipal">>;
+};
+
+// ===== JSON-RPC Types =====
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+  id: string | number;
+}
+
+interface JsonRpcResponse<T = unknown> {
+  jsonrpc: "2.0";
+  result?: T;
+  error?: JsonRpcError;
+  id: string | number | null;
+}
+
+interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
+// ===== Client Options =====
+
+export interface MeClientOptions {
+  server?: string;
+  apiKey?: string;
+  timeout?: number;
+  retries?: number;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+const MAX_RETRY_DELAY = 30_000;
+const BASE_DELAY = 500;
+
+export function createClient(options: MeClientOptions = {}) {
+  const server = options.server ?? "http://localhost:3000";
+  const timeout = options.timeout ?? 30000;
+  const maxRetries = options.retries ?? 3;
+
+  let apiKey = options.apiKey;
+  let requestId = 0;
+
+  const rpcUrl = `${server}/rpc`;
+
+  function setApiKey(key: string | undefined): void {
+    apiKey = key;
+  }
+
+  function getApiKey(): string | undefined {
+    return apiKey;
+  }
+
+  async function fetchRpc<T>(
+    body: JsonRpcRequest | JsonRpcRequest[],
+    label: string,
+  ): Promise<T> {
+    for (let attempt = 0; ; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const headers: Record<string, string> = {
+          "Content-Type": "application/json",
+        };
+        if (apiKey) {
+          headers.Authorization = `Bearer ${apiKey}`;
+        }
+        const res = await fetch(rpcUrl, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          signal: controller.signal,
+        });
+        if (!res.ok) {
+          if (attempt < maxRetries && RETRYABLE_STATUS_CODES.has(res.status)) {
+            const retryAfter = res.headers.get("Retry-After");
+            const delayMs = retryAfter
+              ? Math.min(Number(retryAfter) * 1000, MAX_RETRY_DELAY)
+              : Math.min(
+                  BASE_DELAY * 2 ** attempt + Math.random() * BASE_DELAY,
+                  MAX_RETRY_DELAY,
+                );
+            await sleep(delayMs);
+            continue;
+          }
+          throw new Error(`HTTP error: ${res.status} ${res.statusText}`);
+        }
+        return (await res.json()) as T;
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          if (attempt < maxRetries) {
+            const delayMs = Math.min(
+              BASE_DELAY * 2 ** attempt + Math.random() * BASE_DELAY,
+              MAX_RETRY_DELAY,
+            );
+            await sleep(delayMs);
+            continue;
+          }
+          throw new Error(`Request timeout: ${label}`);
+        }
+        // Retry on network errors (TypeError from fetch)
+        if (error instanceof TypeError && attempt < maxRetries) {
+          const delayMs = Math.min(
+            BASE_DELAY * 2 ** attempt + Math.random() * BASE_DELAY,
+            MAX_RETRY_DELAY,
+          );
+          await sleep(delayMs);
+          continue;
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+
+  async function call<M extends RpcMethodName>(
+    method: M,
+    ...args: RpcInput<M> extends Record<string, never>
+      ? []
+      : [params: RpcInput<M>]
+  ): Promise<RpcOutput<M>> {
+    const request: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      method,
+      params: args[0],
+      id: ++requestId,
+    };
+
+    const response = await fetchRpc<JsonRpcResponse<RpcOutput<M>>>(
+      request,
+      method,
+    );
+
+    if (response.error) {
+      throw Object.assign(new Error(response.error.message), {
+        code: response.error.code,
+        data: response.error.data,
+      });
+    }
+
+    const schema = getOutputSchema(method);
+    if (schema) {
+      const parsed = schema.safeParse(response.result);
+      if (!parsed.success) {
+        throw new Error(
+          `Invalid response for ${method}: ${parsed.error.message}`,
+        );
+      }
+      return parsed.data as RpcOutput<M>;
+    }
+
+    return response.result as RpcOutput<M>;
+  }
+
+  async function callRaw<T>(method: string, params?: unknown): Promise<T> {
+    const request: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      method,
+      params,
+      id: ++requestId,
+    };
+
+    const response = await fetchRpc<JsonRpcResponse<T>>(request, method);
+
+    if (response.error) {
+      throw Object.assign(new Error(response.error.message), {
+        code: response.error.code,
+        data: response.error.data,
+      });
+    }
+
+    return response.result as T;
+  }
+
+  async function batch<T extends unknown[]>(
+    requests: { method: string; params?: unknown }[],
+  ): Promise<T> {
+    if (requests.length === 0) {
+      return [] as unknown as T;
+    }
+
+    const batchRequests: JsonRpcRequest[] = requests.map((req) => ({
+      jsonrpc: "2.0",
+      method: req.method,
+      params: req.params,
+      id: ++requestId,
+    }));
+
+    const idToIndex = new Map<string | number, number>();
+    batchRequests.forEach((req, index) => {
+      idToIndex.set(req.id, index);
+    });
+
+    const responses = await fetchRpc<JsonRpcResponse[]>(batchRequests, "batch");
+
+    const results: unknown[] = new Array(requests.length);
+    for (const response of responses) {
+      if (response.id == null) continue;
+      const index = idToIndex.get(response.id);
+      if (index !== undefined) {
+        if (response.error) {
+          results[index] = Object.assign(new Error(response.error.message), {
+            code: response.error.code,
+            data: response.error.data,
+          });
+        } else {
+          results[index] = response.result;
+        }
+      }
+    }
+
+    // Fill any missing responses (sparse array holes) with errors
+    for (let i = 0; i < results.length; i++) {
+      if (results[i] === undefined) {
+        results[i] = new Error("No response received for batch request");
+      }
+    }
+
+    return results as T;
+  }
+
+  // Build namespace objects
+  const engram: EngramNamespace = {
+    create: (params) => call("engram.create", params),
+    get: (params) => call("engram.get", params),
+    search: (params) => call("engram.search", params),
+    update: (params) => call("engram.update", params),
+    delete: (params) => call("engram.delete", params),
+    batchCreate: (params) => call("engram.batchCreate", params),
+    mv: (params) => call("engram.mv", params),
+  };
+
+  const auth: AuthNamespace = {
+    login: (params) => call("auth.login", params),
+    whoami: () => call("auth.whoami"),
+    createApiKey: (params) => call("auth.createApiKey", params),
+    listApiKeys: () => call("auth.listApiKeys"),
+    revokeApiKey: (params) => call("auth.revokeApiKey", params),
+  };
+
+  const principal: PrincipalNamespace = {
+    list: () => call("principal.list"),
+    get: (params) => call("principal.get", params),
+    create: (params) => call("principal.create", params),
+    delete: (params) => call("principal.delete", params),
+    setPassword: (params) => call("principal.setPassword", params),
+  };
+
+  const grant: GrantNamespace = {
+    create: (params) => call("grant.create", params),
+    revoke: (params) => call("grant.revoke", params),
+    list: (params) => call("grant.list", params ?? {}),
+    check: (params) => call("grant.check", params),
+  };
+
+  const owner: OwnerNamespace = {
+    set: (params) => call("owner.set", params),
+    remove: (params) => call("owner.remove", params),
+    get: (params) => call("owner.get", params),
+    list: (params) => call("owner.list", params ?? {}),
+  };
+
+  const role: RoleNamespace = {
+    addMember: (params) => call("role.addMember", params),
+    removeMember: (params) => call("role.removeMember", params),
+    listMembers: (params) => call("role.listMembers", params),
+    listForPrincipal: (params) => call("role.listForPrincipal", params ?? {}),
+  };
+
+  return {
+    call,
+    callRaw,
+    batch,
+    setApiKey,
+    getApiKey,
+
+    engram,
+    auth,
+    principal,
+    grant,
+    owner,
+    role,
+  };
+}
+
+export type MeClient = ReturnType<typeof createClient>;
+
+// Re-export types from shared schemas for convenience
+export type {
+  ApiKey,
+  CreateApiKeyResult,
+  CreateEngramParams,
+  CreatePrincipalParams,
+  Engram,
+  EngramWithScore,
+  LoginResult,
+  MvEngramParams,
+  MvEngramResult,
+  Principal,
+  PrincipalDetail,
+  PrincipalListItem,
+  PrincipalRole,
+  RoleMember,
+  RpcInput,
+  RpcMethodName,
+  RpcOutput,
+  SearchEngramParams,
+  SearchEngramResult,
+  TreeGrant,
+  TreeOwner,
+  UpdateEngramParams,
+  Whoami,
+} from "./schemas";

package/src/schemas/auth.ts

@@ -0,0 +1,79 @@
+/**
+ * Auth schemas - shared between server and client
+ */
+import { z } from "zod";
+
+// ===== Input Schemas =====
+
+export const registerSchema = z.object({
+  email: z.email(),
+  password: z.string().min(8),
+  name: z.string().min(1),
+});
+
+export const loginSchema = z.object({
+  identifier: z.string().min(1),
+  password: z.string(),
+});
+
+export const createApiKeySchema = z.object({
+  name: z.string().min(1),
+});
+
+export const revokeApiKeySchema = z.object({
+  keyId: z.string(),
+});
+
+// ===== Output Schemas =====
+
+export const principalSchema = z.object({
+  id: z.uuidv7(),
+  email: z.email().nullable(),
+  name: z.string(),
+  superuser: z.boolean(),
+  createrole: z.boolean(),
+  can_login: z.boolean(),
+});
+
+export const loginResultSchema = z.object({
+  key: z.string(),
+  principal: principalSchema,
+});
+
+export const whoamiSchema = z.object({
+  principalId: z.uuidv7(),
+  name: z.string(),
+  email: z.email().nullable(),
+  superuser: z.boolean(),
+  createrole: z.boolean(),
+  can_login: z.boolean(),
+});
+
+export const apiKeySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  expires_at: z.string(),
+  created_at: z.string(),
+});
+
+export const createApiKeyResultSchema = z.object({
+  key: z.string(),
+  id: z.string(),
+});
+
+export const successSchema = z.object({
+  success: z.literal(true),
+});
+
+// ===== Inferred Types =====
+
+export type LoginParams = z.infer<typeof loginSchema>;
+export type CreateApiKeyParams = z.infer<typeof createApiKeySchema>;
+export type RevokeApiKeyParams = z.infer<typeof revokeApiKeySchema>;
+
+export type Principal = z.infer<typeof principalSchema>;
+export type LoginResult = z.infer<typeof loginResultSchema>;
+export type Whoami = z.infer<typeof whoamiSchema>;
+export type ApiKey = z.infer<typeof apiKeySchema>;
+export type CreateApiKeyResult = z.infer<typeof createApiKeyResultSchema>;
+export type Success = z.infer<typeof successSchema>;