@ikeboy003/cloudrest-client 0.0.1

package/src/rpc.ts

@@ -0,0 +1,54 @@
+// RPC caller. Posts JSON args to `/rpc/<name>` and returns the parsed body.
+// Awaitable directly (PromiseLike), matching the QueryBuilder ergonomics:
+//
+//   const result = await db.rpc("update_mastery", { p_concept_id, p_correct: true });
+//
+// PostgREST RPC convention:
+//   - POST /rpc/<fn>  body = { argName: value, ... }
+//   - Response is the function return — scalar, row, or set-of rows.
+
+import type { ExecContext } from "./query.js";
+import { CloudRestError } from "./errors.js";
+
+export class RpcCaller<Result = unknown> implements PromiseLike<Result> {
+  constructor(
+    private readonly ctx: ExecContext,
+    private readonly fn: string,
+    private readonly args: Record<string, unknown> = {},
+  ) {}
+
+  private async exec(): Promise<Result> {
+    const url = `${this.ctx.baseUrl}/rpc/${this.fn}`;
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      ...this.ctx.headers,
+    };
+    const token = await this.ctx.getToken?.();
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+
+    const res = await this.ctx.fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(this.args),
+    });
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new CloudRestError(res.status, res.statusText, body);
+    }
+
+    // Functions returning void produce 204; everything else returns JSON.
+    if (res.status === 204) return undefined as Result;
+    const text = await res.text();
+    if (!text) return undefined as Result;
+    return JSON.parse(text) as Result;
+  }
+
+  then<T1 = Result, T2 = never>(
+    onfulfilled?: ((value: Result) => T1 | PromiseLike<T1>) | null,
+    onrejected?: ((reason: unknown) => T2 | PromiseLike<T2>) | null,
+  ): PromiseLike<T1 | T2> {
+    return this.exec().then(onfulfilled, onrejected as never);
+  }
+}

package/src/serialize.ts

@@ -0,0 +1,38 @@
+// PostgREST-grammar value serialization. Mirrors the server's parser
+// expectations: see cloudrest-workerd/src/parser/operators.ts.
+//
+// Rules:
+// - null  → "null"  (use with `is.null`, never `eq.null`)
+// - Date  → ISO string
+// - array → "(a,b,c)" with each element quoted if it contains special chars
+// - string with special chars → wrapped in double quotes, internal " → \"
+
+// Scalar values: only `,` and `"` need quoting. Parens / dots / spaces
+// are fine bare — wrapping them in quotes makes the server search for
+// the literal quoted string and return 0 rows.
+const SCALAR_SPECIAL = /[,"]/;
+// List items are inside `(a,b,c)`, so `(`, `)`, and `,` all need quoting.
+const LIST_SPECIAL = /[(),."]/;
+
+export function serializeValue(v: unknown): string {
+  if (v === null || v === undefined) return "null";
+  if (v instanceof Date) return v.toISOString();
+  if (Array.isArray(v)) return `(${v.map(serializeListItem).join(",")})`;
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number" || typeof v === "bigint") return String(v);
+  return escapeIfNeeded(String(v), SCALAR_SPECIAL);
+}
+
+function serializeListItem(v: unknown): string {
+  if (v === null || v === undefined) return "null";
+  if (v instanceof Date) return v.toISOString();
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number" || typeof v === "bigint") return String(v);
+  return escapeIfNeeded(String(v), LIST_SPECIAL);
+}
+
+function escapeIfNeeded(s: string, special: RegExp): string {
+  if (s === "") return '""';
+  if (!special.test(s)) return s;
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+// Generic helpers that let callers parameterize the client with their
+// openapi-typescript-generated `paths` interface.
+//
+// Usage:
+//   import type { paths } from "./schema";
+//   const db = createClient<paths>({ baseUrl, getToken });
+
+export type AnyPaths = Record<string, any>;
+
+// Extract the GET response row type for a table path, e.g. "/canvas_assignments".
+// openapi-typescript emits: paths["/x"]["get"]["responses"][200]["content"]["application/json"]
+// which is `Array<Row>`. We unwrap to `Row`.
+export type RowOf<P extends AnyPaths, T extends keyof P> =
+  P[T] extends { get: { responses: { 200: { content: { "application/json": infer Body } } } } }
+    ? Body extends ReadonlyArray<infer Item>
+      ? Item
+      : Body
+    : never;
+
+// Tables = path keys that look like top-level table routes ("/foo", not "/rpc/...").
+export type TableName<P extends AnyPaths> = Extract<keyof P, string>;
+
+// Token getter: sync or async, may return null when unauthenticated.
+export type TokenGetter = () => string | null | Promise<string | null>;
+
+export interface ClientOptions {
+  baseUrl: string;
+  getToken?: TokenGetter;
+  headers?: Record<string, string>;
+  fetch?: typeof fetch;
+}