@jskit-ai/http-runtime 0.1.4

package/test/paginationQuery.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createPaginationQuerySchema } from "../src/shared/validators/paginationQuery.js";
+
+test("createPaginationQuerySchema uses expected defaults", () => {
+  const schema = createPaginationQuerySchema();
+
+  assert.equal(schema.type, "object");
+  assert.equal(schema.additionalProperties, false);
+  assert.equal(schema.properties.page.minimum, 1);
+  assert.equal(schema.properties.page.default, 1);
+  assert.equal(schema.properties.pageSize.minimum, 1);
+  assert.equal(schema.properties.pageSize.maximum, 100);
+  assert.equal(schema.properties.pageSize.default, 10);
+});
+
+test("createPaginationQuerySchema applies custom bounds and defaults", () => {
+  const schema = createPaginationQuerySchema({
+    defaultPage: 2,
+    defaultPageSize: 25,
+    minPage: 2,
+    minPageSize: 5,
+    maxPageSize: 250
+  });
+
+  assert.equal(schema.properties.page.minimum, 2);
+  assert.equal(schema.properties.page.default, 2);
+  assert.equal(schema.properties.pageSize.minimum, 5);
+  assert.equal(schema.properties.pageSize.maximum, 250);
+  assert.equal(schema.properties.pageSize.default, 25);
+});

package/test/providerRuntime.httpClient.test.js

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { HttpClientRuntimeServiceProvider } from "../src/server/providers/HttpClientRuntimeServiceProvider.js";
+import { HttpClientRuntimeClientProvider } from "../src/client/providers/HttpClientRuntimeClientProvider.js";
+
+function createSingletonApp() {
+  const singletons = new Map();
+  return {
+    singletons,
+    singleton(token, factory) {
+      singletons.set(token, factory(this));
+    }
+  };
+}
+
+test("HttpClientRuntimeServiceProvider registers runtime http client api", () => {
+  const app = createSingletonApp();
+  const provider = new HttpClientRuntimeServiceProvider();
+  provider.register(app);
+
+  assert.equal(app.singletons.has("runtime.http-client"), true);
+  const api = app.singletons.get("runtime.http-client");
+  assert.equal(typeof api.createHttpClient, "function");
+});
+
+test("HttpClientRuntimeClientProvider registers client http client api", () => {
+  const app = createSingletonApp();
+  const provider = new HttpClientRuntimeClientProvider();
+  provider.register(app);
+
+  assert.equal(app.singletons.has("runtime.http-client.client"), true);
+  const api = app.singletons.get("runtime.http-client.client");
+  assert.equal(typeof api.createHttpClient, "function");
+});

package/test/providerRuntime.validators.test.js

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { HttpValidatorsServiceProvider } from "../src/server/providers/HttpValidatorsServiceProvider.js";
+import { HttpValidatorsClientProvider } from "../src/client/providers/HttpValidatorsClientProvider.js";
+
+function createSingletonApp() {
+  const singletons = new Map();
+  return {
+    singletons,
+    singleton(token, factory) {
+      singletons.set(token, factory(this));
+    }
+  };
+}
+
+test("HttpValidatorsServiceProvider registers shared validators api", () => {
+  const app = createSingletonApp();
+  const provider = new HttpValidatorsServiceProvider();
+  provider.register(app);
+
+  assert.equal(app.singletons.has("validators.http"), true);
+  const api = app.singletons.get("validators.http");
+  assert.equal(typeof api.withStandardErrorResponses, "function");
+  assert.equal(typeof api.createResource, "function");
+  assert.equal(typeof api.createCommand, "function");
+});
+
+test("HttpValidatorsClientProvider registers client validators api", () => {
+  const app = createSingletonApp();
+  const provider = new HttpValidatorsClientProvider();
+  provider.register(app);
+
+  assert.equal(app.singletons.has("validators.http.client"), true);
+  const api = app.singletons.get("validators.http.client");
+  assert.equal(typeof api.withStandardErrorResponses, "function");
+  assert.equal(typeof api.createResource, "function");
+  assert.equal(typeof api.createCommand, "function");
+});

package/test/resource.test.js

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Type } from "@fastify/type-provider-typebox";
+import {
+  createCursorPagedListResponseSchema,
+  createResource
+} from "../src/shared/validators/resource.js";
+
+test("createCursorPagedListResponseSchema builds items + nextCursor schema", () => {
+  const itemSchema = Type.Object(
+    {
+      id: Type.Integer({ minimum: 1 })
+    },
+    { additionalProperties: false }
+  );
+  const listSchema = createCursorPagedListResponseSchema(itemSchema);
+
+  assert.equal(listSchema.type, "object");
+  assert.equal(listSchema.additionalProperties, false);
+  assert.equal(listSchema.properties.items.type, "array");
+  assert.equal(listSchema.properties.nextCursor.anyOf.length, 2);
+});
+
+test("createResource requires record/create/replace/patch schemas", () => {
+  assert.throws(
+    () => createResource({}),
+    /record must be a TypeBox schema object/
+  );
+});
+
+test("createResource builds default list schema from record/listItem", () => {
+  const recordSchema = Type.Object(
+    {
+      id: Type.Integer({ minimum: 1 }),
+      name: Type.String({ minLength: 1 })
+    },
+    { additionalProperties: false }
+  );
+  const writeSchema = Type.Object(
+    {
+      name: Type.String({ minLength: 1 }),
+      color: Type.String({ minLength: 1 })
+    },
+    { additionalProperties: false }
+  );
+  const patchSchema = Type.Partial(writeSchema, { additionalProperties: false });
+  const resource = createResource({
+    record: recordSchema,
+    create: writeSchema,
+    replace: writeSchema,
+    patch: patchSchema
+  });
+
+  assert.equal(resource.list.properties.items.items.type, "object");
+});
+
+test("createResource accepts explicit list schema override", () => {
+  const recordSchema = Type.Object(
+    {
+      id: Type.Integer({ minimum: 1 })
+    },
+    { additionalProperties: false }
+  );
+  const writeSchema = Type.Object(
+    {
+      id: Type.Integer({ minimum: 1 })
+    },
+    { additionalProperties: false }
+  );
+  const patchSchema = Type.Partial(writeSchema, { additionalProperties: false });
+  const explicitListSchema = Type.Object(
+    {
+      rows: Type.Array(recordSchema),
+      meta: Type.Object(
+        {
+          page: Type.Integer({ minimum: 1 }),
+          pageSize: Type.Integer({ minimum: 1 })
+        },
+        { additionalProperties: false }
+      )
+    },
+    { additionalProperties: false }
+  );
+
+  const resource = createResource({
+    record: recordSchema,
+    create: writeSchema,
+    replace: writeSchema,
+    patch: patchSchema,
+    list: explicitListSchema
+  });
+
+  assert.equal(resource.list, explicitListSchema);
+});

package/test/retry.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { shouldRetryForCsrfFailure } from "../src/shared/clientRuntime/retry.js";
+
+test("shouldRetryForCsrfFailure returns true only for unsafe csrf 403 before retry", () => {
+  const unsafeMethods = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+
+  assert.equal(
+    shouldRetryForCsrfFailure({
+      response: { status: 403 },
+      method: "POST",
+      state: { csrfRetried: false },
+      data: { details: { code: "FST_CSRF_INVALID_TOKEN" } },
+      unsafeMethods
+    }),
+    true
+  );
+
+  assert.equal(
+    shouldRetryForCsrfFailure({
+      response: { status: 403 },
+      method: "GET",
+      state: { csrfRetried: false },
+      data: { details: { code: "FST_CSRF_INVALID_TOKEN" } },
+      unsafeMethods
+    }),
+    false
+  );
+
+  assert.equal(
+    shouldRetryForCsrfFailure({
+      response: { status: 403 },
+      method: "POST",
+      state: { csrfRetried: true },
+      data: { details: { code: "FST_CSRF_INVALID_TOKEN" } },
+      unsafeMethods
+    }),
+    false
+  );
+});

package/test/typeboxFormats.test.js

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { registerTypeBoxFormats, __testables } from "../src/shared/validators/typeboxFormats.js";
+
+test("strict uuid validator accepts canonical lowercase v4/v5 values", () => {
+  assert.equal(__testables.isStrictUuid("aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"), true);
+  assert.equal(__testables.isStrictUuid("aaaaaaaa-aaaa-5aaa-8aaa-aaaaaaaaaaaa"), true);
+  assert.equal(__testables.isStrictUuid("AAAAAAAA-AAAA-4AAA-8AAA-AAAAAAAAAAAA"), false);
+  assert.equal(__testables.isStrictUuid("not-a-uuid"), false);
+});
+
+test("strict iso utc date-time validator accepts only canonical millisecond UTC", () => {
+  assert.equal(__testables.isStrictIsoUtcDateTime("2024-01-01T00:00:00.000Z"), true);
+  assert.equal(__testables.isStrictIsoUtcDateTime("2024-01-01T00:00:00Z"), false);
+  assert.equal(__testables.isStrictIsoUtcDateTime("2024-01-01T00:00:00.000+01:00"), false);
+  assert.equal(__testables.isStrictIsoUtcDateTime("2024-02-30T00:00:00.000Z"), false);
+});
+
+test("registerTypeBoxFormatsWith only sets missing validators", () => {
+  const setCalls = [];
+  const registry = {
+    existing: new Set(["uuid"]),
+    Has(name) {
+      return this.existing.has(name);
+    },
+    Set(name, fn) {
+      setCalls.push([name, fn]);
+      this.existing.add(name);
+    }
+  };
+
+  __testables.registerTypeBoxFormatsWith(registry);
+
+  assert.equal(setCalls.length, 1);
+  assert.equal(setCalls[0][0], "iso-utc-date-time");
+});
+
+test("registerTypeBoxFormats is callable", () => {
+  registerTypeBoxFormats();
+  assert.equal(typeof registerTypeBoxFormats, "function");
+});

package/test/validationErrors.test.js

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  normalizeFieldErrors,
+  resolveFieldErrors,
+  createValidationFailure,
+  createHttpError
+} from "../src/client/index.js";
+
+test("normalizeFieldErrors trims keys and stringifies values", () => {
+  const normalized = normalizeFieldErrors({
+    " name ": "Required",
+    count: 3,
+    "": "skip-me",
+    "   ": "skip-me-too"
+  });
+
+  assert.deepEqual(normalized, {
+    name: "Required",
+    count: "3"
+  });
+});
+
+test("resolveFieldErrors reads top-level and nested details field errors", () => {
+  assert.deepEqual(
+    resolveFieldErrors({
+      fieldErrors: {
+        email: "Invalid email."
+      }
+    }),
+    {
+      email: "Invalid email."
+    }
+  );
+
+  assert.deepEqual(
+    resolveFieldErrors({
+      details: {
+        fieldErrors: {
+          password: "Too short."
+        }
+      }
+    }),
+    {
+      password: "Too short."
+    }
+  );
+});
+
+test("createValidationFailure returns canonical validation envelope", () => {
+  const failure = createValidationFailure({
+    error: "Validation failed.",
+    code: "validation_failed",
+    fieldErrors: {
+      name: "Name is required."
+    }
+  });
+
+  assert.deepEqual(failure, {
+    error: "Validation failed.",
+    code: "validation_failed",
+    fieldErrors: {
+      name: "Name is required."
+    },
+    details: {
+      fieldErrors: {
+        name: "Name is required."
+      }
+    }
+  });
+});
+
+test("createHttpError normalizes code and fieldErrors", () => {
+  const error = createHttpError(
+    {
+      status: 422
+    },
+    {
+      error: "Validation failed.",
+      code: "invalid_input",
+      details: {
+        fieldErrors: {
+          " email ": "Invalid email."
+        }
+      }
+    }
+  );
+
+  assert.equal(error.status, 422);
+  assert.equal(error.code, "invalid_input");
+  assert.deepEqual(error.fieldErrors, {
+    email: "Invalid email."
+  });
+  assert.deepEqual(error.details, {
+    fieldErrors: {
+      " email ": "Invalid email."
+    }
+  });
+});