@functional-systems/lambdadb 0.3.2 → 0.3.3

package/src/models/operations/getbulkupsertdocs.ts

@@ -3,7 +3,7 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
+import { nullToUndefined, safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
@@ -101,10 +101,10 @@ export const GetBulkUpsertDocsResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   url: z.string(),
-  type: Type$inboundSchema.default("application/json"),
-  httpMethod: HttpMethod$inboundSchema.default("PUT"),
+  type: nullToUndefined(Type$inboundSchema.default("application/json")),
+  httpMethod: nullToUndefined(HttpMethod$inboundSchema.default("PUT")),
   objectKey: z.string(),
-  sizeLimitBytes: z.number().int().default(209715200),
+  sizeLimitBytes: nullToUndefined(z.number().int().default(209715200)),
 });
 
 export function getBulkUpsertDocsResponseFromJSON(

package/src/models/operations/listcollections.ts

@@ -3,7 +3,7 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
+import { nullToUndefined, safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
@@ -50,7 +50,7 @@ export const ListCollectionsResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   collections: z.array(models.CollectionResponse$inboundSchema),
-  nextPageToken: z.string().optional(),
+  nextPageToken: nullToUndefined(z.string().optional()),
 });
 
 export function listCollectionsResponseFromJSON(

package/src/models/operations/listdocs.ts

@@ -3,7 +3,7 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
+import { nullToUndefined, safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -89,9 +89,9 @@ export const ListDocsResponse$inboundSchema: z.ZodType<
 > = z.object({
   total: z.number().int(),
   docs: z.array(ListDocsDoc$inboundSchema),
-  nextPageToken: z.string().optional(),
+  nextPageToken: nullToUndefined(z.string().optional()),
   isDocsInline: z.boolean(),
-  docsUrl: z.string().optional(),
+  docsUrl: nullToUndefined(z.string().optional()),
 });
 
 export function listDocsResponseFromJSON(

package/src/models/operations/querycollection.ts

@@ -4,7 +4,7 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
+import { nullToUndefined, safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import * as models from "../index.js";
@@ -156,7 +156,7 @@ export const QueryCollectionDoc$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   collection: z.string(),
-  score: z.number().optional(),
+  score: nullToUndefined(z.number().optional()),
   doc: z.record(z.any()),
 });
 
@@ -177,11 +177,11 @@ export const QueryCollectionResponse$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   took: z.number().int(),
-  maxScore: z.number().optional(),
+  maxScore: nullToUndefined(z.number().optional()),
   total: z.number().int(),
   docs: z.array(z.lazy(() => QueryCollectionDoc$inboundSchema)),
   isDocsInline: z.boolean(),
-  docsUrl: z.string().optional(),
+  docsUrl: nullToUndefined(z.string().optional()),
 });
 
 export function queryCollectionResponseFromJSON(

package/src/models/partitionconfig.ts

@@ -3,7 +3,7 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../lib/schemas.js";
+import { nullToUndefined, safeParse } from "../lib/schemas.js";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
@@ -47,9 +47,9 @@ export const PartitionConfig$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  fieldName: z.string().optional(),
-  dataType: DataType$inboundSchema.optional(),
-  numPartitions: z.number().int().optional(),
+  fieldName: nullToUndefined(z.string().optional()),
+  dataType: nullToUndefined(DataType$inboundSchema.optional()),
+  numPartitions: nullToUndefined(z.number().int().optional()),
 });
 /** @internal */
 export type PartitionConfig$Outbound = {

package/test/null-response.test.mjs

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { LambdaDBClient } from "../dist/esm/index.js";
+import { HTTPClient } from "../dist/esm/lib/http.js";
+import { ResponseValidationError } from "../dist/esm/models/errors/responsevalidationerror.js";
+import { QueryCollectionResponse$inboundSchema } from "../dist/esm/models/operations/querycollection.js";
+
+function jsonResponse(body, init = {}) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    ...init,
+  });
+}
+
+test("response schemas accept null for optional response fields", () => {
+  const parsed = QueryCollectionResponse$inboundSchema.parse({
+    took: 1,
+    maxScore: null,
+    total: 1,
+    docs: [{ collection: "items", score: null, doc: { id: "a" } }],
+    isDocsInline: false,
+    docsUrl: null,
+  });
+
+  assert.equal(parsed.maxScore, undefined);
+  assert.equal(parsed.docsUrl, undefined);
+  assert.equal(parsed.docs[0].score, undefined);
+});
+
+test("safe methods return ResponseValidationError for invalid JSON bodies", async () => {
+  const httpClient = new HTTPClient({
+    fetcher: async () =>
+      new Response("{", {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      }),
+  });
+  const client = new LambdaDBClient({ httpClient, projectApiKey: "test-key" });
+
+  const result = await client.listCollectionsSafe();
+
+  assert.equal(result.ok, false);
+  assert.ok(result.error instanceof ResponseValidationError);
+  assert.equal(result.error.rawValue, "{");
+});
+
+test("docsUrl fetches treat null document payloads as an empty docs array", async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => jsonResponse(null);
+
+  try {
+    const httpClient = new HTTPClient({
+      fetcher: async () =>
+        jsonResponse({
+          total: 1,
+          docs: [],
+          isDocsInline: false,
+          docsUrl: "https://example.test/docs.json",
+        }),
+    });
+    const client = new LambdaDBClient({ httpClient, projectApiKey: "test-key" });
+
+    const result = await client.collection("items").docs.listSafe();
+
+    assert.equal(result.ok, true);
+    assert.deepEqual(result.value.docs, []);
+    assert.equal(result.value.isDocsInline, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/test/public-api.test.mjs

@@ -0,0 +1,210 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  BadRequestError,
+  HTTPClient,
+  LambdaDBClient,
+} from "../dist/esm/index.js";
+
+const BASE_URL = "https://api.test";
+const PROJECT_NAME = "project-one";
+
+function jsonResponse(body, init = {}) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    ...init,
+  });
+}
+
+function collectionFixture(collectionName, overrides = {}) {
+  return {
+    projectName: PROJECT_NAME,
+    collectionName,
+    indexConfigs: {},
+    numPartitions: 1,
+    numDocs: 2,
+    sourceProjectName: null,
+    sourceCollectionName: null,
+    sourceCollectionVersionId: null,
+    collectionStatus: "ACTIVE",
+    createdAt: 1700000000,
+    updatedAt: 1700000100,
+    dataUpdatedAt: 1700000200,
+    ...overrides,
+  };
+}
+
+function createClient(handler) {
+  const calls = [];
+  const httpClient = new HTTPClient({
+    fetcher: async (request) => {
+      const body = await request.clone().text();
+      const call = {
+        body,
+        headers: Object.fromEntries(request.headers.entries()),
+        method: request.method,
+        url: new URL(request.url),
+      };
+      calls.push(call);
+      return handler(call, calls.length - 1);
+    },
+  });
+
+  const client = new LambdaDBClient({
+    baseUrl: BASE_URL,
+    httpClient,
+    projectApiKey: "test-key",
+    projectName: PROJECT_NAME,
+  });
+
+  return { calls, client };
+}
+
+test("public client lists collections with project URL, auth header, and Date conversion", async () => {
+  const { calls, client } = createClient(() =>
+    jsonResponse({
+      collections: [collectionFixture("alpha")],
+      nextPageToken: null,
+    })
+  );
+
+  const result = await client.listCollections({ size: 5 });
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].method, "GET");
+  assert.equal(calls[0].url.pathname, "/projects/project-one/collections");
+  assert.equal(calls[0].url.searchParams.get("size"), "5");
+  assert.equal(calls[0].headers["x-api-key"], "test-key");
+  assert.equal(result.nextPageToken, undefined);
+  assert.equal(result.collections[0].collectionName, "alpha");
+  assert.ok(result.collections[0].createdAt instanceof Date);
+  assert.equal(result.collections[0].createdAt.toISOString(), "2023-11-14T22:13:20.000Z");
+});
+
+test("public pagination helpers collect all collection pages", async () => {
+  const { calls, client } = createClient((call, index) => {
+    if (index === 0) {
+      return jsonResponse({
+        collections: [collectionFixture("alpha")],
+        nextPageToken: "next-page",
+      });
+    }
+
+    assert.equal(call.url.searchParams.get("pageToken"), "next-page");
+    return jsonResponse({
+      collections: [collectionFixture("beta")],
+      nextPageToken: null,
+    });
+  });
+
+  const result = await client.listAllCollections({ size: 1 });
+
+  assert.equal(calls.length, 2);
+  assert.deepEqual(
+    result.collections.map((collection) => collection.collectionName),
+    ["alpha", "beta"],
+  );
+});
+
+test("collection docs helpers paginate through the user-facing scoped API", async () => {
+  const { calls, client } = createClient((call, index) => {
+    assert.equal(call.method, "GET");
+    assert.equal(call.url.pathname, "/projects/project-one/collections/items/docs");
+
+    if (index === 0) {
+      return jsonResponse({
+        total: 2,
+        docs: [{ collection: "items", doc: { id: "a" } }],
+        nextPageToken: "docs-page-2",
+        isDocsInline: true,
+        docsUrl: null,
+      });
+    }
+
+    assert.equal(call.url.searchParams.get("pageToken"), "docs-page-2");
+    return jsonResponse({
+      total: 2,
+      docs: [{ collection: "items", doc: { id: "b" } }],
+      nextPageToken: null,
+      isDocsInline: true,
+      docsUrl: null,
+    });
+  });
+
+  const result = await client.collection("items").docs.listAll({ size: 1 });
+
+  assert.equal(calls.length, 2);
+  assert.equal(result.total, 2);
+  assert.deepEqual(result.docs, [
+    { collection: "items", doc: { id: "a" } },
+    { collection: "items", doc: { id: "b" } },
+  ]);
+});
+
+test("collection query fetches docsUrl and returns inline docs through the public API", async () => {
+  const originalFetch = globalThis.fetch;
+  const docsUrlCalls = [];
+  globalThis.fetch = async (input) => {
+    docsUrlCalls.push(String(input));
+    return jsonResponse({
+      docs: [{ collection: "items", score: 0.9, doc: { id: "a" } }],
+    });
+  };
+
+  try {
+    const { calls, client } = createClient((call) => {
+      assert.equal(call.method, "POST");
+      assert.equal(call.url.pathname, "/projects/project-one/collections/items/query");
+      assert.deepEqual(JSON.parse(call.body), {
+        query: { text: "hello" },
+        consistentRead: false,
+        includeVectors: false,
+      });
+
+      return jsonResponse({
+        took: 7,
+        maxScore: null,
+        total: 1,
+        docs: [],
+        isDocsInline: false,
+        docsUrl: "https://download.test/query-docs.json",
+      });
+    });
+
+    const result = await client.collection("items").querySafe({
+      query: { text: "hello" },
+    });
+
+    assert.equal(calls.length, 1);
+    assert.deepEqual(docsUrlCalls, ["https://download.test/query-docs.json"]);
+    assert.equal(result.ok, true);
+    assert.equal(result.value.isDocsInline, true);
+    assert.deepEqual(result.value.docs, [
+      { collection: "items", score: 0.9, doc: { id: "a" } },
+    ]);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test("public safe methods expose typed API errors", async () => {
+  const { client } = createClient((call) => {
+    assert.equal(call.method, "POST");
+    assert.equal(call.url.pathname, "/projects/project-one/collections");
+
+    return jsonResponse(
+      { message: null },
+      { status: 400 },
+    );
+  });
+
+  const result = await client.createCollectionSafe({ collectionName: "items" });
+
+  assert.equal(result.ok, false);
+  assert.ok(result.error instanceof BadRequestError);
+  assert.equal(result.error.statusCode, 400);
+  assert.equal(result.error.body, "{\"message\":null}");
+  assert.equal(result.error.data$.message, undefined);
+});

package/.devcontainer/devcontainer.json

@@ -1,45 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/images/tree/main/src/typescript-node
-{
-    "name": "TypeScript",
-    "image": "mcr.microsoft.com/devcontainers/typescript-node:1-20-bullseye",
-    // Features to add to the dev container. More info: https://containers.dev/features.
-    // "features": {},
-    // Use 'forwardPorts' to make a list of ports inside the container available locally.
-    // "forwardPorts": [],
-    // Use 'postCreateCommand' to run commands after the container is created.
-    "postCreateCommand": "sudo chmod +x ./.devcontainer/setup.sh && ./.devcontainer/setup.sh",
-    "customizations": {
-        "vscode": {
-            "extensions": [
-                "ms-vscode.vscode-typescript-tslint-plugin",
-                "esbenp.prettier-vscode",
-                "github.vscode-pull-request-github"
-            ],
-            "settings": {
-                "files.eol": "\n",
-                "editor.formatOnSave": true,
-                "typescript.tsc.autoDetect": "on",
-                "typescript.updateImportsOnFileMove.enabled": "always",
-                "typescript.preferences.importModuleSpecifier": "relative",
-                "[typescript]": {
-                    "editor.codeActionsOnSave": {
-                        "source.organizeImports": true
-                    }
-                },
-                "[typescriptreact]": {
-                    "editor.codeActionsOnSave": {
-                        "source.organizeImports": true
-                    }
-                }
-            }
-        },
-        "codespaces": {
-            "openFiles": [
-                ".devcontainer/README.md"
-            ]
-        }
-    }
-    // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-    // "remoteUser": "root"
-}