@sapporta/rest-open-api 3.52.1

package/.babelrc

@@ -0,0 +1,10 @@
+{
+  "presets": [
+    [
+      "@nrwl/js/babel",
+      {
+        "useBuiltIns": "usage"
+      }
+    ]
+  ]
+}

package/.eslintrc.json

@@ -0,0 +1,21 @@
+{
+  "extends": ["../../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {
+        "@typescript-eslint/no-unused-vars": ["warn"],
+        "@typescript-eslint/no-explicit-any": ["warn"]
+      }
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# @sapporta/rest-open-api
+
+Initial Sapporta-maintained fork of `@ts-rest/open-api` from the upstream v4 branch.
+
+This package removes the Anatine OpenAPI dependency and supports caller-provided Zod 4 schema transformers.

package/README.md

@@ -0,0 +1,17 @@
+# @sapporta/rest-open-api
+
+Sapporta-maintained OpenAPI generator forked from `@ts-rest/open-api` v4.
+
+This package supports Sapporta's Zod 4 contract usage and requires callers to provide a schema transformer. It does not depend on `@anatine/zod-openapi`.
+
+Build with:
+
+```bash
+pnpm nx build sapporta-rest-open-api
+```
+
+Test with:
+
+```bash
+pnpm nx test sapporta-rest-open-api
+```

package/jest.config.ts

@@ -0,0 +1,16 @@
+/* eslint-disable */
+export default {
+  displayName: 'sapporta-rest-open-api',
+  preset: '../../../jest.preset.js',
+  globals: {},
+  transform: {
+    '^.+\\.[tj]s$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+      },
+    ],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  testEnvironment: 'node',
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@sapporta/rest-open-api",
+  "version": "3.52.1",
+  "description": "Sapporta-maintained ts-rest OpenAPI generator for Zod 4 contracts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sapporta/sapporta-rest.git",
+    "directory": "libs/ts-rest/open-api"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@sapporta/rest-core": "workspace:*",
+    "openapi3-ts": "^2.0.2"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "zod": "^4.0.0"
+  }
+}

package/project.json

@@ -0,0 +1,51 @@
+{
+  "name": "sapporta-rest-open-api",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/ts-rest/open-api/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/rollup:rollup",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "project": "libs/ts-rest/open-api/package.json",
+        "outputPath": "dist/libs/ts-rest/open-api",
+        "main": "libs/ts-rest/open-api/src/index.ts",
+        "tsConfig": "libs/ts-rest/open-api/tsconfig.lib.json",
+        "assets": [
+          {
+            "glob": "CHANGELOG.md",
+            "input": "libs/ts-rest/open-api",
+            "output": "."
+          },
+          {
+            "glob": "README.md",
+            "input": ".",
+            "output": "."
+          }
+        ],
+        "format": ["esm", "cjs"],
+        "compiler": "tsc",
+        "rollupConfig": "tools/scripts/rollup.config.js",
+        "generateExportsField": true,
+        "updateBuildableProjectDepsInPackageJson": true
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["libs/ts-rest/open-api/**/*.ts"],
+        "ignorePath": ".gitignore"
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/libs/ts-rest/open-api"],
+      "options": {
+        "jestConfig": "libs/ts-rest/open-api/jest.config.ts"
+      }
+    }
+  },
+  "tags": []
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './lib/ts-rest-open-api';
+export {
+  SchemaTransformer,
+  SchemaTransformerAsync,
+  SchemaTransformerSync,
+} from './lib/types';

package/src/lib/contract-traversal.ts

@@ -0,0 +1,217 @@
+import { AppRouter, isAppRoute, isAppRouteOtherResponse } from '@sapporta/rest-core';
+import {
+  AsyncAndSyncHelper,
+  GetAsyncFunction,
+  GetSyncFunction,
+  PathSchemaResults,
+  RouterPath,
+  SchemaTransformerAsync,
+  SchemaTransformerSync,
+} from './types';
+import { getPathParameterSchema } from './parsers/path-params';
+import { getHeaderParameterSchema } from './parsers/headers';
+import { getQueryParameterSchema } from './parsers/query-params';
+import { getBodySchema } from './parsers/body';
+import { SchemaObject } from 'openapi3-ts';
+
+type PerformContractTraversalHelper = AsyncAndSyncHelper<
+  {
+    contract: AppRouter;
+    jsonQuery: boolean;
+  },
+  {
+    transformSchema: SchemaTransformerSync;
+  },
+  {
+    transformSchema: SchemaTransformerAsync;
+  },
+  Array<RouterPath & { schemaResults: PathSchemaResults }>
+>;
+
+/**
+ * Recursively step through the router and get all the individual routes with their paths etc.
+ */
+const getPathsFromRouter = (
+  router: AppRouter,
+  pathHistory?: string[],
+): RouterPath[] => {
+  const paths: RouterPath[] = [];
+
+  Object.keys(router).forEach((key) => {
+    const value = router[key];
+
+    if (isAppRoute(value)) {
+      const pathWithPathParams = value.path.replace(/:(\w+)/g, '{$1}');
+
+      paths.push({
+        id: key,
+        path: pathWithPathParams,
+        route: value,
+        paths: pathHistory ?? [],
+      });
+    } else {
+      paths.push(...getPathsFromRouter(value, [...(pathHistory ?? []), key]));
+    }
+  });
+
+  return paths;
+};
+
+const syncFunc: GetSyncFunction<PerformContractTraversalHelper> = ({
+  contract,
+  transformSchema,
+  jsonQuery,
+}) => {
+  const paths = getPathsFromRouter(contract);
+
+  const results: Array<RouterPath & { schemaResults: PathSchemaResults }> = [];
+
+  for (const path of paths) {
+    const concatenatedPath = [...path.paths, path.id].join('.');
+
+    const pathParams = getPathParameterSchema.sync({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+    });
+
+    const headerParams = getHeaderParameterSchema.sync({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+    });
+
+    const querySchema = getQueryParameterSchema.sync({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+      jsonQuery: !!jsonQuery,
+    });
+
+    const bodySchema = getBodySchema.sync({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+    });
+
+    const responses: Record<string, SchemaObject> = {};
+    for (const [statusCode, _response] of Object.entries(
+      path.route.responses,
+    )) {
+      const schemaValidator = isAppRouteOtherResponse(_response)
+        ? _response.body
+        : _response;
+
+      const responseSchema = transformSchema({
+        schema: schemaValidator,
+        appRoute: path.route,
+        id: path.id,
+        concatenatedPath,
+        type: 'response',
+      });
+
+      if (responseSchema) {
+        responses[statusCode] = responseSchema;
+      }
+    }
+
+    results.push({
+      ...path,
+      schemaResults: {
+        path: pathParams,
+        headers: headerParams,
+        query: querySchema,
+        body: bodySchema,
+        responses,
+      },
+    });
+  }
+
+  return results;
+};
+
+const asyncFunc: GetAsyncFunction<PerformContractTraversalHelper> = async ({
+  contract,
+  transformSchema,
+  jsonQuery,
+}) => {
+  const paths = getPathsFromRouter(contract);
+
+  const results: Array<RouterPath & { schemaResults: PathSchemaResults }> = [];
+
+  for (const path of paths) {
+    const concatenatedPath = [...path.paths, path.id].join('.');
+
+    const pathParams = await getPathParameterSchema.async({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+    });
+
+    const headerParams = await getHeaderParameterSchema.async({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+    });
+
+    const querySchema = await getQueryParameterSchema.async({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+      jsonQuery: !!jsonQuery,
+    });
+
+    const bodySchema = await getBodySchema.async({
+      transformSchema,
+      appRoute: path.route,
+      id: path.id,
+      concatenatedPath,
+    });
+
+    const responses: Record<string, SchemaObject> = {};
+    for (const [statusCode, _response] of Object.entries(
+      path.route.responses,
+    )) {
+      const schemaValidator = isAppRouteOtherResponse(_response)
+        ? _response.body
+        : _response;
+
+      const responseSchema = await transformSchema({
+        schema: schemaValidator,
+        appRoute: path.route,
+        id: path.id,
+        concatenatedPath,
+        type: 'response',
+      });
+
+      if (responseSchema) {
+        responses[statusCode] = responseSchema;
+      }
+    }
+
+    results.push({
+      ...path,
+      schemaResults: {
+        path: pathParams,
+        headers: headerParams,
+        query: querySchema,
+        body: bodySchema,
+        responses,
+      },
+    });
+  }
+
+  return results;
+};
+
+export const performContractTraversal: PerformContractTraversalHelper = {
+  sync: syncFunc,
+  async: asyncFunc,
+};

package/src/lib/parsers/body.ts

@@ -0,0 +1,71 @@
+import { AppRoute } from '@sapporta/rest-core';
+import {
+  AsyncAndSyncHelper,
+  GetAsyncFunction,
+  GetSyncFunction,
+  SchemaTransformerAsync,
+  SchemaTransformerSync,
+} from '../types';
+import { SchemaObject } from 'openapi3-ts';
+
+type GetBodySchemaHelper = AsyncAndSyncHelper<
+  {
+    appRoute: AppRoute;
+    id: string;
+    concatenatedPath: string;
+  },
+  {
+    transformSchema: SchemaTransformerSync;
+  },
+  {
+    transformSchema: SchemaTransformerAsync;
+  },
+  SchemaObject | null
+>;
+
+const syncFunc: GetSyncFunction<GetBodySchemaHelper> = ({
+  transformSchema,
+  appRoute,
+  id,
+  concatenatedPath,
+}) => {
+  const schema = 'body' in appRoute ? appRoute.body : undefined;
+
+  const transformedSchema = transformSchema({
+    schema,
+    appRoute,
+    id,
+    concatenatedPath,
+    type: 'body',
+  });
+
+  if (!transformedSchema) {
+    return null;
+  }
+
+  return transformedSchema;
+};
+
+const asyncFunc: GetAsyncFunction<GetBodySchemaHelper> = async ({
+  transformSchema,
+  appRoute,
+  id,
+  concatenatedPath,
+}) => {
+  const schema = 'body' in appRoute ? appRoute.body : undefined;
+
+  const transformedSchema = await transformSchema({
+    schema,
+    appRoute,
+    id,
+    concatenatedPath,
+    type: 'body',
+  });
+
+  return transformedSchema;
+};
+
+export const getBodySchema: GetBodySchemaHelper = {
+  sync: syncFunc,
+  async: asyncFunc,
+};

package/src/lib/parsers/headers.ts

@@ -0,0 +1,163 @@
+import { AppRoute, isStandardSchema } from '@sapporta/rest-core';
+import {
+  AsyncAndSyncHelper,
+  GetAsyncFunction,
+  GetSyncFunction,
+  SchemaTransformerAsync,
+  SchemaTransformerSync,
+} from '../types';
+import { ParameterObject } from 'openapi3-ts';
+import { schemaObjectToParameters, schemaToParameter } from './utils';
+
+type GetHeaderParameterHelper = AsyncAndSyncHelper<
+  {
+    appRoute: AppRoute;
+    id: string;
+    concatenatedPath: string;
+  },
+  {
+    transformSchema: SchemaTransformerSync;
+  },
+  {
+    transformSchema: SchemaTransformerAsync;
+  },
+  Array<ParameterObject>
+>;
+
+const syncFunc: GetSyncFunction<GetHeaderParameterHelper> = ({
+  transformSchema,
+  appRoute,
+  id,
+  concatenatedPath,
+}) => {
+  const schema = appRoute.headers;
+
+  if (schema === null) {
+    return [];
+  }
+
+  if (schema === undefined) {
+    return [];
+  }
+
+  if (typeof schema === 'symbol') {
+    return [];
+  }
+
+  if (isStandardSchema(schema)) {
+    const transformedSchema = transformSchema({
+      schema,
+      appRoute,
+      id,
+      concatenatedPath,
+      type: 'header',
+    });
+
+    if (!transformedSchema) {
+      return [];
+    }
+
+    return schemaObjectToParameters(transformedSchema, 'header');
+  }
+
+  const parameters: ParameterObject[] = [];
+
+  for (const [key, subSchema] of Object.entries(schema)) {
+    if (isStandardSchema(subSchema)) {
+      const transformedSchema = transformSchema({
+        schema: subSchema,
+        appRoute,
+        id,
+        concatenatedPath,
+        type: 'header',
+      });
+
+      if (!transformedSchema) {
+        return [];
+      }
+
+      parameters.push(...schemaObjectToParameters(transformedSchema, 'header'));
+    }
+  }
+
+  return parameters;
+};
+
+const asyncFunc: GetAsyncFunction<GetHeaderParameterHelper> = async ({
+  transformSchema,
+  appRoute,
+  id,
+  concatenatedPath,
+}) => {
+  const schema = appRoute.headers;
+
+  if (schema === null) {
+    return [];
+  }
+
+  if (schema === undefined) {
+    return [];
+  }
+
+  if (typeof schema === 'symbol') {
+    return [];
+  }
+
+  if (isStandardSchema(schema)) {
+    const transformedSchema = await transformSchema({
+      schema,
+      appRoute,
+      id,
+      concatenatedPath,
+      type: 'header',
+    });
+
+    if (!transformedSchema) {
+      return [];
+    }
+
+    return schemaObjectToParameters(transformedSchema, 'header');
+  }
+
+  const parameters: ParameterObject[] = [];
+
+  for (const [key, subSchema] of Object.entries(schema)) {
+    if (isStandardSchema(subSchema)) {
+      const transformedSchema = await transformSchema({
+        schema: subSchema,
+        appRoute,
+        id,
+        concatenatedPath,
+        type: 'header',
+      });
+
+      if (!transformedSchema) {
+        continue;
+      }
+
+      const validateEmptyResult = subSchema['~standard'].validate(undefined);
+
+      if (validateEmptyResult instanceof Promise) {
+        throw new Error('Schema validation must be synchronous');
+      }
+
+      const isRequired = Boolean(validateEmptyResult.issues?.length);
+
+      const asParameter = schemaToParameter(
+        transformedSchema,
+        'header',
+        isRequired,
+        key,
+        false,
+      );
+      parameters.push(asParameter);
+    }
+  }
+
+  return parameters;
+};
+
+export const getHeaderParameterSchema: GetHeaderParameterHelper = {
+  sync: syncFunc,
+  async: asyncFunc,
+};

package/src/lib/parsers/index.ts

@@ -0,0 +1,5 @@
+export { getPathParameterSchema } from './path-params';
+export { getHeaderParameterSchema } from './headers';
+export { getQueryParameterSchema } from './query-params';
+export { getBodySchema } from './body';
+export * from './utils';