@jskit-ai/http-runtime 0.1.243 → 0.1.244

package/test/client.test.js

@@ -665,6 +665,35 @@ test("request decodes json:api collection responses into JSKIT paged-list shape"
   });
 });
 
+test("request keeps collection resources without ids as distinct records", async () => {
+  const fetchImpl = async () =>
+    mockResponse({
+      contentType: "application/vnd.api+json",
+      data: {
+        data: [
+          { type: "books", attributes: { title: "First" } },
+          { type: "books", attributes: { title: "Second" } }
+        ]
+      }
+    });
+
+  const client = createHttpClient({ fetchImpl });
+  const payload = await client.request("/api/books", {
+    method: "GET",
+    transport: {
+      kind: "jsonapi-resource",
+      responseType: "books",
+      responseKind: "collection"
+    }
+  });
+
+  assert.deepEqual(
+    payload.items.map((item) => item.title),
+    ["First", "Second"]
+  );
+  assert.notEqual(payload.items[0], payload.items[1]);
+});
+
 test("request decodes native json-rest-api collection pagination metadata into JSKIT nextCursor", async () => {
   const fetchImpl = async () =>
     mockResponse({

package/test/entrypoints.boundary.test.js

@@ -4,8 +4,6 @@ import test from "node:test";
 
 import * as clientApi from "../src/client/index.js";
 import * as sharedApi from "../src/shared/index.js";
-import { HttpValidatorsProvider } from "../src/server/providers/HttpValidatorsProvider.js";
-import { HttpClientProvider } from "../src/server/providers/HttpClientProvider.js";
 
 test("package exports include explicit shared entrypoint and no server barrel", async () => {
   const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
@@ -14,24 +12,25 @@ test("package exports include explicit shared entrypoint and no server barrel",
   assert.equal(exportsMap["./shared"], "./src/shared/index.js");
 });
 
-test("client entrypoint exports client runtime helpers and client providers only", () => {
+test("package registers no container providers; callers import its functions directly", async () => {
+  const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+  assert.deepEqual(packageJson.jskit.capabilities.provides, []);
+  assert.deepEqual(packageJson.jskit.runtime.server.providers, []);
+  assert.deepEqual(packageJson.jskit.runtime.client.providers, []);
+  for (const surface of packageJson.jskit.metadata.apiSummary.surfaces) {
+    assert.ok(packageJson.exports[surface.subpath], `apiSummary names a real export: ${surface.subpath}`);
+  }
+});
+
+test("client entrypoint exports client runtime helpers only", () => {
   assert.equal(typeof clientApi.createHttpClient, "function");
   assert.equal(typeof clientApi.createTransientRetryHttpClient, "function");
-  assert.equal(clientApi.HttpValidatorsClientProvider.id, "validators.http.client");
-  assert.equal(clientApi.HttpClientRuntimeClientProvider.id, "runtime.http-client.client");
   assert.equal(typeof clientApi.withStandardErrorResponses, "undefined");
 });
 
-test("server provider modules export declarative providers only", () => {
-  assert.equal(HttpValidatorsProvider.id, "validators.http");
-  assert.equal(HttpClientProvider.id, "runtime.http-client");
-});
-
 test("shared entrypoint exports shared validators only", () => {
   assert.equal(typeof sharedApi.withStandardErrorResponses, "function");
-  assert.equal(typeof sharedApi.enumSchema, "function");
-  assert.equal(typeof sharedApi.createResource, "function");
-  assert.equal(typeof sharedApi.createCommand, "function");
+  assert.equal(typeof sharedApi.validateOperationSection, "function");
   assert.equal(typeof sharedApi.createJsonApiDocument, "function");
   assert.equal(typeof sharedApi.createJsonApiErrorDocumentFromFailure, "function");
   assert.equal(typeof sharedApi.normalizeJsonApiDocument, "function");
@@ -41,5 +40,7 @@ test("shared entrypoint exports shared validators only", () => {
   assert.equal(typeof sharedApi.createJsonApiResourceRouteContract, "function");
   assert.equal(typeof sharedApi.withJsonApiErrorResponses, "function");
   assert.equal(typeof sharedApi.createHttpClient, "undefined");
-  assert.equal(typeof sharedApi.HttpValidatorsProvider, "undefined");
+  for (const removed of ["createResource", "createCommand", "createPaginationQuerySchema", "mapOperationIssues", "enumSchema", "passthroughErrorResponses"]) {
+    assert.equal(typeof sharedApi[removed], "undefined", removed);
+  }
 });

package/test/errorResponses.test.js

@@ -8,7 +8,6 @@ import {
   apiErrorTransportSchema,
   apiValidationErrorTransportSchema,
   fastifyDefaultErrorTransportSchema,
-  enumSchema,
   createTransportResponseSchema,
   withStandardErrorResponses
 } from "../src/shared/validators/errorResponses.js";
@@ -93,16 +92,6 @@ test("withStandardErrorResponses does not override existing error schemas", () =
   assert.equal(responses[400].transportSchema, custom400);
 });
 
-test("enumSchema creates a literal union", () => {
-  const schema = enumSchema(["one", "two", "three"]);
-
-  assert.equal(schema.anyOf.length, 3);
-  assert.deepEqual(
-    schema.anyOf.map((entry) => entry.const),
-    ["one", "two", "three"]
-  );
-});
-
 test("error response validators export transport schemas from the same contracts", () => {
   assert.equal(apiErrorOutputValidator.mode, "replace");
   assert.equal(apiValidationErrorOutputValidator.mode, "replace");

package/test/jsonApiRouteTransport.test.js

@@ -29,7 +29,7 @@ import {
 } from "../src/shared/index.js";
 import { createSchema } from "../../kernel/shared/validators/index.js";
 import { resolveRouteValidatorOptions } from "../../kernel/server/http/lib/routeValidator.js";
-import { registerApiErrorHandler } from "../../kernel/server/runtime/fastifyBootstrap.js";
+import { registerApiErrorHandler } from "../../kernel/server/http/errorHandling.js";
 import { AppError, isAppError } from "../../kernel/server/runtime/errors.js";
 import { createHttpError } from "../src/shared/clientRuntime/errors.js";
 import { createJsonRestApiHost } from "../../json-rest-api-core/src/server/jsonRestApiHost.js";
@@ -141,6 +141,11 @@ test("createJsonApiResourceSuccessTransportSchema wraps plain record schema in a
   const resourceSchema = schema.definitions.contactsSuccessResource;
   assert.deepEqual(resourceSchema.required, ["type", "attributes", "id"]);
   assert.equal(resourceSchema.properties.type.const, "contacts");
+
+  const referencedNames = new Set(
+    [...JSON.stringify(schema).matchAll(/"#\/definitions\/([^"]+)"/g)].map((match) => match[1])
+  );
+  assert.deepEqual(Object.keys(schema.definitions).sort(), [...referencedNames].sort());
 });
 
 test("createJsonApiResourceRouteTransport unwraps request payloads and wraps resource/error responses", () => {
@@ -242,7 +247,7 @@ test("real HTTP responses classify typed JSON REST read and write errors", async
     for (const wrapped of [false, true]) {
       const prefix = `/${jsonapi ? "jsonapi" : "plain"}/${wrapped ? "write" : "read"}`;
       app.get(`${prefix}/:kind`, {
-        config: jsonapi ? { transport: { runtime: transport } } : {},
+        config: jsonapi ? { transport } : {},
         ...(jsonapi ? {} : { schema: { response: { "4xx": apiErrorTransportSchema, "5xx": apiErrorTransportSchema } } })
       }, async (request) => {
         const [, createError] = cases.find(([name]) => name === request.params.kind);
@@ -306,7 +311,7 @@ test("real resource validation, permission hooks and completion failures retain
   const transport = createJsonApiResourceRouteTransport({ type: "books" });
   for (const jsonapi of [false, true]) {
     const prefix = `/${jsonapi ? "jsonapi" : "plain"}`;
-    const options = { config: jsonapi ? { transport: { runtime: transport } } : {} };
+    const options = { config: jsonapi ? { transport } : {} };
     app.get(`${prefix}/denied`, options, async () => api.resources.books.query({}, { deny: true }));
     app.post(`${prefix}/invalid`, options, async (request) => api.resources.books.post({ data: request.body }));
     app.post(`${prefix}/committed`, options, async (request) => api.resources.books.post({ data: request.body }, { failAfterCommit: true }));
@@ -336,7 +341,7 @@ test("real resource validation, permission hooks and completion failures retain
 
 test("error handler, JSON:API transport and client preserve outcomes without disclosing internal failures", () => {
   const transport = createJsonApiResourceRouteTransport({ type: "books" });
-  const app = { log: { error() {} }, setErrorHandler(handler) { this.errorHandler = handler; } };
+  const app = { log: { error() {}, info() {} }, setErrorHandler(handler) { this.errorHandler = handler; } };
   registerApiErrorHandler(app, { isAppError });
 
   for (const transactionOutcome of ["none", "pending", "committed", "rolledBack", "unknown", "invalid", undefined]) {
@@ -355,7 +360,7 @@ test("error handler, JSON:API transport and client preserve outcomes without dis
         header(name, value) { this.headers[name] = value; return this; },
         send(payload) { this.payload = payload; return this; }
       };
-      app.errorHandler(failure, jsonapi ? { routeTransport: transport } : {}, reply);
+      app.errorHandler(failure, jsonapi ? { routeOptions: { config: { transport } } } : {}, reply);
       assert.equal(reply.statusCode, 500);
       const clientError = createHttpError({ status: reply.statusCode }, reply.payload);
       assert.equal(clientError.message, "Internal server error.");
@@ -382,7 +387,7 @@ test("JSON:API field errors retain outcomes and permission details remain privat
   assert.equal(payload.errors.length, 2);
   assert.ok(payload.errors.every((error) => error.meta.transactionOutcome === "rolledBack"));
 
-  const app = { log: { error() {} }, setErrorHandler(handler) { this.errorHandler = handler; } };
+  const app = { log: { error() {}, info() {} }, setErrorHandler(handler) { this.errorHandler = handler; } };
   registerApiErrorHandler(app, { isAppError });
   const reply = {
     code() { return this; },
@@ -392,7 +397,7 @@ test("JSON:API field errors retain outcomes and permission details remain privat
   app.errorHandler(new AppError(403, "Forbidden.", {
     code: "ACTION_PERMISSION_DENIED",
     details: { fieldErrors: { secret: "Required private permission" } }
-  }), { routeTransport: transport }, reply);
+  }), { routeOptions: { config: { transport } } }, reply);
   assert.deepEqual(reply.payload, {
     errors: [{ status: "403", code: "ACTION_PERMISSION_DENIED", title: "Forbidden." }]
   });

package/test/operationValidation.test.js

@@ -2,10 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createSchema } from "json-rest-schema";
 
-import {
-  validateOperationInput,
-  validateOperationSection
-} from "../src/shared/validators/operationValidation.js";
+import { validateOperationSection } from "../src/shared/validators/operationValidation.js";
 
 const patchOperation = Object.freeze({
   method: "PATCH",
@@ -194,66 +191,21 @@ test("validateOperationSection surfaces custom validator failures as field error
 
   assert.equal(parsed.ok, false);
   assert.equal(parsed.fieldErrors.adenovirusValidTo, "Adenovirus valid-to date is required when vaccinated.");
-  assert.deepEqual(parsed.globalErrors, []);
+  assert.deepEqual(Object.keys(parsed).sort(), ["fieldErrors", "ok", "value"]);
 });
 
-test("validateOperationInput validates params/query/body together", () => {
-  const viewOperation = Object.freeze({
-    method: "GET",
-    params: {
-      schema: createSchema({
-        workspaceSlug: { type: "string", required: true, minLength: 1 }
-      }),
-      mode: "patch"
-    },
-    query: {
-      schema: createSchema({
-        includeArchived: { type: "boolean", strictBoolean: true }
-      }),
-      mode: "patch"
-    }
-  });
-
-  const parsed = validateOperationInput({
-    operation: viewOperation,
-    input: {
-      params: {
-        workspaceSlug: "acme"
-      },
-      query: {}
-    }
+test("validateOperationSection returns only ok, value and fieldErrors", () => {
+  const valid = validateOperationSection({
+    operation: patchOperation,
+    section: "body",
+    value: { name: "Acme" }
   });
-
-  assert.equal(parsed.ok, true);
-  assert.equal(parsed.value.params.workspaceSlug, "acme");
-  assert.deepEqual(parsed.value.query, {});
-  assert.equal(parsed.value.body, undefined);
-});
-
-test("validateOperationInput collects json-rest-schema field errors", () => {
-  const parsed = validateOperationInput({
-    operation: {
-      body: {
-        schema: createSchema({
-          name: {
-            type: "string",
-            required: true,
-            minLength: 1,
-            messages: {
-              minLength: "Name is required."
-            }
-          }
-        }),
-        mode: "patch"
-      }
-    },
-    input: {
-      body: {
-        name: "   "
-      }
-    }
+  const missingSection = validateOperationSection({
+    operation: patchOperation,
+    section: "query",
+    value: { page: "1" }
   });
 
-  assert.equal(parsed.ok, false);
-  assert.equal(parsed.fieldErrors.name, "Name is required.");
+  assert.deepEqual(valid, { ok: true, value: { name: "Acme" }, fieldErrors: {} });
+  assert.deepEqual(missingSection, { ok: true, value: { page: "1" }, fieldErrors: {} });
 });

package/test/transientRetryHttpClient.test.js

@@ -235,3 +235,14 @@ for (const phase of ["headers", "body"]) {
     });
   });
 }
+
+test("createTransientRetryHttpClient exposes no request path that bypasses transient retry", async () => {
+  const client = createTransientRetryHttpClient({ fetchImpl: async () => mockResponse() });
+
+  assert.deepEqual(Object.keys(client).sort(), [
+    "clearCsrfTokenCache",
+    "ensureCsrfToken",
+    "request",
+    "requestStream"
+  ]);
+});

package/test/validationErrors.test.js

@@ -5,7 +5,9 @@ import {
   normalizeFieldErrors,
   resolveFieldErrors,
   createValidationFailure,
-  createHttpError
+  createHttpError,
+  createNetworkError,
+  isGenericHttpErrorMessage
 } from "../src/client/index.js";
 
 test("normalizeFieldErrors trims keys and stringifies values", () => {
@@ -105,15 +107,15 @@ test("createHttpError preserves standard error envelopes that also contain an er
       status: 409
     },
     {
-      code: "vibe64_repository_flip_active_sessions",
+      code: "resource_conflict",
       details: {
-        code: "vibe64_repository_flip_active_sessions"
+        code: "resource_conflict"
       },
-      error: "Finish or abandon active sessions before changing this project's repository mode.",
+      error: "Finish the pending operation first.",
       errors: [
         {
-          code: "vibe64_repository_flip_active_sessions",
-          message: "Finish or abandon active sessions before changing this project's repository mode."
+          code: "resource_conflict",
+          message: "Finish the pending operation first."
         }
       ],
       ok: false
@@ -121,13 +123,13 @@ test("createHttpError preserves standard error envelopes that also contain an er
   );
 
   assert.equal(error.status, 409);
-  assert.equal(error.code, "vibe64_repository_flip_active_sessions");
+  assert.equal(error.code, "resource_conflict");
   assert.equal(
     error.message,
-    "Finish or abandon active sessions before changing this project's repository mode."
+    "Finish the pending operation first."
   );
   assert.deepEqual(error.details, {
-    code: "vibe64_repository_flip_active_sessions"
+    code: "resource_conflict"
   });
 });
 
@@ -181,3 +183,12 @@ test("createHttpError decodes json:api error documents into the existing fieldEr
     }
   });
 });
+
+test("isGenericHttpErrorMessage recognises only the transport's own wording", () => {
+  assert.equal(isGenericHttpErrorMessage(createHttpError({ status: 500 }, {})), true);
+  assert.equal(isGenericHttpErrorMessage(createNetworkError(new Error("offline"))), true);
+  assert.equal(isGenericHttpErrorMessage(createHttpError({ status: 500 }, { error: "Server exploded" })), false);
+  assert.equal(isGenericHttpErrorMessage({ statusCode: 404, message: "Request failed with status 404." }), true);
+  assert.equal(isGenericHttpErrorMessage({ message: "Request failed with status 500." }), false);
+  assert.equal(isGenericHttpErrorMessage(null), false);
+});

package/src/client/providers/HttpClientRuntimeClientProvider.js

@@ -1,20 +0,0 @@
-import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
-import * as httpClientRuntime from "../../shared/clientRuntime/index.js";
-
-const HTTP_CLIENT_RUNTIME_CLIENT_API = Object.freeze({
-  ...httpClientRuntime
-});
-
-const HttpClientRuntimeClientProvider = defineProvider({
-  id: "runtime.http-client.client",
-  provides: {
-    httpClient: "runtime.http-client.client"
-  },
-  setup() {
-    return {
-      httpClient: HTTP_CLIENT_RUNTIME_CLIENT_API
-    };
-  }
-});
-
-export { HttpClientRuntimeClientProvider };

package/src/client/providers/HttpValidatorsClientProvider.js

@@ -1,16 +0,0 @@
-import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
-import { HTTP_VALIDATORS_API } from "../../shared/validators/httpValidatorsApi.js";
-
-const HttpValidatorsClientProvider = defineProvider({
-  id: "validators.http.client",
-  provides: {
-    validators: "validators.http.client"
-  },
-  setup() {
-    return {
-      validators: HTTP_VALIDATORS_API
-    };
-  }
-});
-
-export { HttpValidatorsClientProvider };

package/src/server/providers/HttpClientProvider.js

@@ -1,16 +0,0 @@
-import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
-import * as httpClient from "../../shared/clientRuntime/index.js";
-
-const HttpClientProvider = defineProvider({
-  id: "runtime.http-client",
-  provides: {
-    httpClient: "runtime.http-client"
-  },
-  setup() {
-    return {
-      httpClient: Object.freeze({ ...httpClient })
-    };
-  }
-});
-
-export { HttpClientProvider };

package/src/server/providers/HttpValidatorsProvider.js

@@ -1,16 +0,0 @@
-import { defineProvider } from "@jskit-ai/kernel/shared/capabilities";
-import { HTTP_VALIDATORS_API } from "../../shared/validators/httpValidatorsApi.js";
-
-const HttpValidatorsProvider = defineProvider({
-  id: "validators.http",
-  provides: {
-    validators: "validators.http"
-  },
-  setup() {
-    return {
-      validators: HTTP_VALIDATORS_API
-    };
-  }
-});
-
-export { HttpValidatorsProvider };

package/src/shared/clientRuntime/index.js

@@ -1,4 +0,0 @@
-export { createHttpClient } from "./client.js";
-export { createHttpError, createNetworkError } from "./errors.js";
-export { DEFAULT_RETRYABLE_CSRF_ERROR_CODES, shouldRetryForCsrfFailure } from "./retry.js";
-export { normalizeHeaderName, hasHeader, setHeaderIfMissing } from "./headers.js";

package/src/shared/validators/command.js

@@ -1,24 +0,0 @@
-import { asSchemaDefinition } from "./schemaUtils.js";
-import { normalizeUniqueTextList } from "@jskit-ai/kernel/shared/support/normalize";
-import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
-
-function createCommand({
-  input,
-  output,
-  idempotent = null,
-  invalidates = []
-} = {}) {
-  const command = {
-    input: asSchemaDefinition(input, "input", "patch"),
-    output: asSchemaDefinition(output, "output", "replace"),
-    invalidates: Object.freeze(normalizeUniqueTextList(invalidates))
-  };
-
-  if (typeof idempotent === "boolean") {
-    command.idempotent = idempotent;
-  }
-
-  return deepFreeze(command);
-}
-
-export { createCommand };

package/src/shared/validators/httpValidatorsApi.js

@@ -1,129 +0,0 @@
-import { createPaginationQuerySchema } from "./paginationQuery.js";
-import {
-  fieldErrorsFieldDefinition,
-  apiErrorDetailsSchema,
-  apiValidationErrorDetailsSchema,
-  apiErrorOutputValidator,
-  apiValidationErrorOutputValidator,
-  apiErrorTransportSchema,
-  apiValidationErrorTransportSchema,
-  fastifyDefaultErrorTransportSchema,
-  STANDARD_ERROR_STATUS_CODES,
-  createTransportResponseSchema,
-  passthroughErrorResponses,
-  withStandardErrorResponses,
-  enumSchema
-} from "./errorResponses.js";
-import {
-  createCursorPagedListResponseSchema,
-  createResource
-} from "./resource.js";
-import { createCommand } from "./command.js";
-import {
-  resolveSchemaMessages,
-  resolveFieldSchema,
-  resolveIssueField,
-  resolveMissingRequiredFields,
-  resolveIssueMessageFromSchema,
-  mapOperationIssues
-} from "./operationMessages.js";
-import {
-  validateOperationSection,
-  validateOperationInput
-} from "./operationValidation.js";
-import {
-  JSON_API_CONTENT_TYPE,
-  createJsonApiDocument,
-  createJsonApiErrorDocumentFromFailure,
-  createJsonApiErrorObject,
-  createJsonApiResourceObject,
-  isJsonApiCollectionDocument,
-  isJsonApiContentType,
-  isJsonApiErrorDocument,
-  isJsonApiResourceDocument,
-  isJsonContentType,
-  normalizeJsonApiDocument,
-  normalizeJsonApiResourceObject,
-  resolveJsonApiTransportTypes,
-  simplifyJsonApiDocument
-} from "./jsonApiTransport.js";
-import {
-  JSON_API_QUERY_PAGE_CURSOR_KEY,
-  JSON_API_QUERY_PAGE_LIMIT_KEY,
-  JSON_API_QUERY_INCLUDE_KEY,
-  JSON_API_QUERY_SORT_KEY,
-  mapPlainQueryKeyToTransportKey,
-  mapTransportQueryKeyToPlainKey,
-  encodeJsonApiResourceQueryObject,
-  decodeJsonApiResourceQueryObject,
-  createJsonApiResourceQueryTransportSchema
-} from "./jsonApiQueryTransport.js";
-import {
-  JSON_API_ERROR_DOCUMENT_SCHEMA,
-  createJsonApiResourceObjectTransportSchema,
-  createJsonApiResourceRequestBodyTransportSchema,
-  createJsonApiResourceSuccessTransportSchema,
-  withJsonApiErrorResponses,
-  createJsonApiResourceRouteTransport,
-  createJsonApiResourceRouteContract
-} from "./jsonApiRouteTransport.js";
-
-const HTTP_VALIDATORS_API = Object.freeze({
-  createPaginationQuerySchema,
-  fieldErrorsFieldDefinition,
-  apiErrorDetailsSchema,
-  apiValidationErrorDetailsSchema,
-  apiErrorOutputValidator,
-  apiValidationErrorOutputValidator,
-  apiErrorTransportSchema,
-  apiValidationErrorTransportSchema,
-  fastifyDefaultErrorTransportSchema,
-  STANDARD_ERROR_STATUS_CODES,
-  createTransportResponseSchema,
-  passthroughErrorResponses,
-  withStandardErrorResponses,
-  enumSchema,
-  createCursorPagedListResponseSchema,
-  createResource,
-  createCommand,
-  resolveSchemaMessages,
-  resolveFieldSchema,
-  resolveIssueField,
-  resolveMissingRequiredFields,
-  resolveIssueMessageFromSchema,
-  mapOperationIssues,
-  validateOperationSection,
-  validateOperationInput,
-  JSON_API_CONTENT_TYPE,
-  createJsonApiDocument,
-  createJsonApiErrorDocumentFromFailure,
-  createJsonApiErrorObject,
-  createJsonApiResourceObject,
-  isJsonApiCollectionDocument,
-  isJsonApiContentType,
-  isJsonApiErrorDocument,
-  isJsonApiResourceDocument,
-  isJsonContentType,
-  normalizeJsonApiDocument,
-  normalizeJsonApiResourceObject,
-  resolveJsonApiTransportTypes,
-  simplifyJsonApiDocument,
-  JSON_API_QUERY_PAGE_CURSOR_KEY,
-  JSON_API_QUERY_PAGE_LIMIT_KEY,
-  JSON_API_QUERY_INCLUDE_KEY,
-  JSON_API_QUERY_SORT_KEY,
-  mapPlainQueryKeyToTransportKey,
-  mapTransportQueryKeyToPlainKey,
-  encodeJsonApiResourceQueryObject,
-  decodeJsonApiResourceQueryObject,
-  createJsonApiResourceQueryTransportSchema,
-  JSON_API_ERROR_DOCUMENT_SCHEMA,
-  createJsonApiResourceObjectTransportSchema,
-  createJsonApiResourceRequestBodyTransportSchema,
-  createJsonApiResourceSuccessTransportSchema,
-  withJsonApiErrorResponses,
-  createJsonApiResourceRouteTransport,
-  createJsonApiResourceRouteContract
-});
-
-export { HTTP_VALIDATORS_API };

package/src/shared/validators/jsonApiResponses.js

@@ -1,3 +0,0 @@
-export {
-  simplifyJsonApiDocument
-} from "./jsonApiTransport.js";