@aligent/nx-openapi 0.1.0

package/README.md

@@ -0,0 +1,76 @@
+# OpenAPI REST Client Generator Nx Plugin
+
+Generate typed REST clients from OpenAPI 3.0+ Specifications.
+
+This plugin was generated with [Nx](https://nx.dev).
+
+The openapi-plugin can create api clients based on local or remote schema files. The source files must be .yaml or .json and must adhere to the OpenAPI Specification 3.0+
+
+## Usage
+
+### Generating a new client
+
+To build a new client in the clients folder:
+
+- Run `nx g @aligent/nx-openapi:client`
+- Follow the prompts to name and provide a source file
+
+To build with flags (without needing to prompt):
+Run `nx g @aligent/nx-openapi:client` with optional flags:
+
+- `--name` Name of the api client.
+- `--schemaPath` Absolute path to the schema. This can be a valid HTTP URL or a local file.
+- `--importPath` The package name used to import the client. Defaults to `@clients/{name}` if not supplied
+- `--configPath` path to the redocly config file responsible for authentication when fetching a schema remotely. For more information: https://openapi-ts.dev/cli#auth.
+- `--skipValidate` If passed, this will skip schema pre-validation. Only do this if you have good reason to - not validating the schema beforehand may produce unpredictable results (either things may not generate at all or they may generate something that is incorrect).
+- `--override` Override the schema (and the generated type) of an existing client.
+
+**:rotating_light: Do not edit the files in the `/generated` folder after generating a client. These files are generated using the OpenAPI Schema and editing them may put you at risk of no longer conforming to the specifications of the API you are using! :rotating_light:**
+
+### Regenerating types for an existing client
+
+To regenerate an existing client run the same generator command again (as above) and pass in `--override` flag. If the client already exists, its types file will be regenerated from the provided one.
+
+## Development
+
+### Building
+
+Run `nx run nx-openapi:build` to build the library.
+
+### Running unit tests
+
+Run `nx run nx-openapi:test` to execute the unit tests.
+
+### Details
+
+The plugin was created following the standards for Nx custom plugins. It contains a single `generator.ts` file which is responsible for the main logic behind generating the client.
+For more information on client generation check [Nx plugin documentation](https://nx.dev/features/generate-code)
+
+Normally, plugin generators take pre-defined files specified in the `/files` directory and automatically use that a basis for writing to a `Tree` object (the data structure Nx uses to generate files).
+
+Since we are using `openapi-typescript` to generate files in real time, we can't create a pre-defined template. Instead perform write operations to the `Tree` ourselves. We do this by taking the output of the Typescript generation and calling a built in `write` process, to write the generated code into a file as part of the generation.
+
+The flow for the generator is as follows:
+
+```mermaid
+graph LR;
+  R[Receive path arguments from Nx cli]-->GL[Get local schema from filesystem];
+  R-->GR[Get remote schema from url];
+  GL-->G[Generate TS];
+  GR-->G;
+  G-->W[Write generated .ts file to tree];
+  W-->NX[Nx generator uses tree to build directory];
+  NX-->C[Clean up];
+```
+
+## What gets generated?
+
+The generator will generate two main things:
+
+A `types` file that will contain several typescript interfaces depending on the OpenAPI schema specification it was passed:
+
+- `paths`: Defines the routes that the API has as well as what parameters you can pass into them and what you should expect in return. [More information](https://swagger.io/docs/specification/v3_0/paths-and-operations/#paths)
+- `operations`: The defined operations that can be performed on a given path. [More information.](https://swagger.io/docs/specification/v3_0/paths-and-operations/#operations)
+- `components`: A way of avoid duplication when paths or operations contain the same structure in their responses. Components define a structure that is used multiple time throughout the API. [More information.](https://swagger.io/docs/specification/v3_0/components/)
+
+A `client` file that will contain some commented, boilerplate code to help you get started.

package/generators.json

@@ -0,0 +1,9 @@
+{
+    "generators": {
+        "client": {
+            "factory": "./src/generators/client/generator",
+            "schema": "./src/generators/client/schema.json",
+            "description": "Generate a new openapi REST client"
+        }
+    }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@aligent/nx-openapi",
+  "version": "0.1.0",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aligent/microservice-development-utilities.git",
+    "directory": "packages/nx-openapi"
+  },
+  "dependencies": {
+    "@nx/devkit": "20.8.1",
+    "@redocly/openapi-core": "^1.34.2",
+    "openapi-typescript": "^7.6.1",
+    "typescript": "^5.8.3"
+  },
+  "generators": "./generators.json",
+  "author": "Aligent",
+  "license": "MIT",
+  "types": "./src/index.d.ts"
+}

package/src/generators/client/files/README.md.template

@@ -0,0 +1 @@
+The <%= name %> REST API Client was generated using Nx Generators and openapi-typescript codegen

package/src/generators/client/files/src/client.ts.template

@@ -0,0 +1,22 @@
+// The following is an example file generated to demonstrate how to use your newly generated types
+import { paths } from '../generated';
+import createClient from 'openapi-fetch';
+
+// This type is an example of what is initialised using the types generated in the paths interface which is created when generation occurs.
+// Its worth looking into that paths interface, to see the the types that were generated for your client.
+type ExampleResponse =
+    paths['/customers']['get']['responses']['200']['content']['application/json'];
+
+// Using openapi-fetch we can create a fully typed REST client by passing in paths as a generic.
+// If you wish however, you can use any api client you want (axios, basic fetch etc.) and use the paths separately to maintain type safety in your client.
+const client = createClient<paths>({
+    baseUrl: '',
+    signal: AbortSignal.timeout(10000),
+});
+
+// Client getters are then fully typed. Try deleting '/customers' and seeing what routes you can use!
+const response = client.GET('/customers', {
+    params: {
+        query: {},
+    },
+});

package/src/generators/client/files/tsconfig.json.template

@@ -0,0 +1,10 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "esModuleInterop": true
+    },
+    "include": [
+        "src/**/*.ts",
+        "**/*.test.ts"
+    ]
+}

package/src/generators/client/generator.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { ClientGeneratorSchema } from './schema';
+export declare function clientGenerator(tree: Tree, options: ClientGeneratorSchema): Promise<void>;
+export default clientGenerator;

package/src/generators/client/generator.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientGenerator = clientGenerator;
+const devkit_1 = require("@nx/devkit");
+const generate_openapi_types_1 = require("../../helpers/generate-openapi-types");
+const utilities_1 = require("../../helpers/utilities");
+const VALID_EXTENSIONS = ['yaml', 'yml', 'json'];
+async function clientGenerator(tree, options) {
+    const { name, schemaPath, importPath = `@clients/${name}`, skipValidate, override } = options;
+    const ext = schemaPath.split('.').pop() || '';
+    if (!VALID_EXTENSIONS.includes(ext)) {
+        throw new Error(`Invalid schema file extension: ${ext}`);
+    }
+    if (!skipValidate) {
+        const hasError = await (0, generate_openapi_types_1.validateSchema)(schemaPath);
+        if (hasError) {
+            throw new Error('Schema validation failed!');
+        }
+    }
+    const projectRoot = `clients/${name}`;
+    const schemaDest = `${projectRoot}/schema.${ext}`;
+    const typesDest = `${projectRoot}/generated/index.ts`;
+    const isNewProject = (0, utilities_1.attemptToAddProjectConfiguration)(tree, name, projectRoot);
+    if (!isNewProject && !override) {
+        devkit_1.logger.info(`Project ${name} already exists. Use --override to override the existing schema.`);
+        return;
+    }
+    await (0, generate_openapi_types_1.copySchema)(tree, schemaDest, schemaPath);
+    await (0, generate_openapi_types_1.generateOpenApiTypes)(tree, schemaDest, typesDest);
+    if (isNewProject) {
+        devkit_1.logger.info(`Creating new project at ${projectRoot}`);
+        // Generate other files
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files'), projectRoot, options);
+        // Add the project to the tsconfig paths so it can be imported by namespace
+        (0, utilities_1.addTsConfigPath)(tree, importPath, [(0, devkit_1.joinPathFragments)(projectRoot, './src', 'index.ts')]);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = clientGenerator;

package/src/generators/client/schema.d.ts

@@ -0,0 +1,8 @@
+export interface ClientGeneratorSchema {
+    name: string;
+    schemaPath: string;
+    configPath?: string;
+    importPath?: string;
+    skipValidate: boolean;
+    override: boolean;
+}

package/src/generators/client/schema.json

@@ -0,0 +1,45 @@
+{
+    "$schema": "https://json-schema.org/schema",
+    "$id": "Client",
+    "type": "object",
+    "description": "Aligent OpenAPI Client plugin generator. This generator is used for generating type-safe REST API clients using OpenAPI 3.0 Schema files. ",
+    "properties": {
+        "name": {
+            "type": "string",
+            "description": "Name of the api client.",
+            "$default": {
+                "$source": "argv",
+                "index": 0
+            },
+            "x-prompt": "Name of your api client: "
+        },
+        "schemaPath": {
+            "type": "string",
+            "description": "Absolute path to the schema. Specify a valid HTTP url or a local file.",
+            "$default": {
+                "$source": "argv",
+                "index": 1
+            },
+            "x-prompt": "Absolute schema path (a valid HTTP url or a local file): "
+        },
+        "configPath": {
+            "type": "string",
+            "description": "Path to the redocly config file responsible for auth. For more information: https://openapi-ts.dev/cli#auth."
+        },
+        "importPath": {
+            "type": "string",
+            "description": "The package name used to import the client, like @myorg/my-awesome-client. Defaults to @clients/{name} if not supplied"
+        },
+        "skipValidate": {
+            "type": "boolean",
+            "description": "Skip validation in the generation process",
+            "default": false
+        },
+        "override": {
+            "type": "boolean",
+            "description": "Override existing project schema",
+            "default": false
+        }
+    },
+    "required": ["name", "schemaPath"]
+}

package/src/generators/client/unit-test-schemas/invalid.yaml

@@ -0,0 +1,26 @@
+openapi: 3.0.0
+info:
+  title: Sample API
+  description: Optional multiline or single-line description in [CommonMark](http://commonmark.org/help/) or HTML.
+  version: 0.1.9
+
+servers:
+  - url: http://api.example.com/v1
+    description: Optional server description, e.g. Main (production) server
+  - url: http://staging-api.example.com
+    description: Optional server description, e.g. Internal staging server for testing
+
+paths:
+  /users:
+    get:
+      summary: Returns a list of users.
+      description: Optional extended description in CommonMark or HTML.
+      responses:
+        '200': # status code
+          description: A JSON array of user names
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string

package/src/generators/client/unit-test-schemas/unsupported.yaml

@@ -0,0 +1,26 @@
+# openapi: 3.0.0
+info:
+  title: Sample API
+  description: Optional multiline or single-line description in [CommonMark](http://commonmark.org/help/) or HTML.
+  version: 0.1.9
+
+servers:
+  - url: http://api.example.com/v1
+    description: Optional server description, e.g. Main (production) server
+  - url: http://staging-api.example.com
+    description: Optional server description, e.g. Internal staging server for testing
+
+paths:
+  /users:
+    get:
+      summary: Returns a list of users.
+      description: Optional extended description in CommonMark or HTML.
+      responses:
+        '200': # status code
+          description: A JSON array of user names
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string

package/src/generators/client/unit-test-schemas/valid.yaml

@@ -0,0 +1,33 @@
+openapi: 3.0.0
+info:
+  title: Sample API
+  description: Optional multiline or single-line description in [CommonMark](http://commonmark.org/help/) or HTML.
+  version: 0.1.9
+security:
+  - sampleScheme: []
+
+servers:
+  - url: http://api.example.com/v1
+    description: Optional server description, e.g. Main (production) server
+  - url: http://staging-api.example.com
+    description: Optional server description, e.g. Internal staging server for testing
+
+paths:
+  /users:
+    get:
+      summary: Returns a list of users.
+      description: Optional extended description in CommonMark or HTML.
+      responses:
+        '200': # status code
+          description: A JSON array of user names
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  type: string
+components:
+  securitySchemes:
+    sampleScheme:
+      type: http
+      scheme: basic

package/src/helpers/generate-openapi-types.d.ts

@@ -0,0 +1,35 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Generates TypeScript types from an OpenAPI schema
+ * and writes the generated types to a specified destination.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} schemaPath - The path to the OpenAPI schema file.
+ * @param {string} typeDest - The destination path for the generated TypeScript types.
+ * @returns {Promise<void>} A promise that resolves when the types are successfully generated.
+ * @throws {Error} If the schema cannot be read or the types cannot be generated.
+ */
+export declare function generateOpenApiTypes(tree: Tree, schemaPath: string, typeDest: string): Promise<void>;
+/**
+ * Copies the OpenAPI schema from the source to a specified destination.
+ *
+ * This function supports both local and remote schemas. If the schema is remote (HTTP/HTTPS),
+ * it fetches the schema from the URL. If the schema is local, it reads the schema from the file system.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} destination - The destination path where the schema will be copied.
+ * @param {string} schemaPath - The path to the schema file (local or remote).
+ * @returns {Promise<void>} A promise that resolves when the schema is successfully copied.
+ * @throws {Error} If the schema cannot be read or is empty.
+ */
+export declare function copySchema(tree: Tree, destination: string, schemaPath: string): Promise<void>;
+/**
+ * Validates an OpenAPI schema using the Redocly OpenAPI linter.
+ *
+ * This function uses the `@redocly/openapi-core` library to lint the schema at the specified path.
+ * It logs warnings and errors based on the severity of the issues found in the schema.
+ *
+ * @param {string} path - The path to the OpenAPI schema file.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if validation errors are found, otherwise `false`.
+ */
+export declare function validateSchema(path: string): Promise<boolean>;

package/src/helpers/generate-openapi-types.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOpenApiTypes = generateOpenApiTypes;
+exports.copySchema = copySchema;
+exports.validateSchema = validateSchema;
+const devkit_1 = require("@nx/devkit");
+const openapi_core_1 = require("@redocly/openapi-core");
+const fs_1 = require("fs");
+const openapi_typescript_1 = __importStar(require("openapi-typescript"));
+/**
+ * Generates TypeScript types from an OpenAPI schema
+ * and writes the generated types to a specified destination.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} schemaPath - The path to the OpenAPI schema file.
+ * @param {string} typeDest - The destination path for the generated TypeScript types.
+ * @returns {Promise<void>} A promise that resolves when the types are successfully generated.
+ * @throws {Error} If the schema cannot be read or the types cannot be generated.
+ */
+async function generateOpenApiTypes(tree, schemaPath, typeDest) {
+    devkit_1.logger.info(`Generating types from ${schemaPath}`);
+    const schema = tree.read(schemaPath);
+    if (!schema) {
+        throw new Error(`Failed to read schema at ${schemaPath}`);
+    }
+    const ast = await (0, openapi_typescript_1.default)(schema);
+    tree.write(typeDest, (0, openapi_typescript_1.astToString)(ast));
+}
+// We do not want to test this function.
+// It only downloads/copies the schema to a specified destination.
+/* v8 ignore start */
+/**
+ * Copies the OpenAPI schema from the source to a specified destination.
+ *
+ * This function supports both local and remote schemas. If the schema is remote (HTTP/HTTPS),
+ * it fetches the schema from the URL. If the schema is local, it reads the schema from the file system.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} destination - The destination path where the schema will be copied.
+ * @param {string} schemaPath - The path to the schema file (local or remote).
+ * @returns {Promise<void>} A promise that resolves when the schema is successfully copied.
+ * @throws {Error} If the schema cannot be read or is empty.
+ */
+async function copySchema(tree, destination, schemaPath) {
+    const isRemoteSchema = schemaPath.startsWith('http://') || schemaPath.startsWith('https://');
+    let schema;
+    // TODO: MI-203 - Support private schema endpoint
+    if (isRemoteSchema) {
+        const response = await fetch(schemaPath);
+        schema = Buffer.from(await response.arrayBuffer());
+    }
+    else {
+        schema = (0, fs_1.readFileSync)(schemaPath);
+    }
+    if (!schema || !schema.length) {
+        throw new Error(`Failed to read schema at ${schemaPath}`);
+    }
+    tree.write(destination, schema);
+}
+/* v8 ignore end */
+/**
+ * Validates an OpenAPI schema using the Redocly OpenAPI linter.
+ *
+ * This function uses the `@redocly/openapi-core` library to lint the schema at the specified path.
+ * It logs warnings and errors based on the severity of the issues found in the schema.
+ *
+ * @param {string} path - The path to the OpenAPI schema file.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if validation errors are found, otherwise `false`.
+ */
+async function validateSchema(path) {
+    let hasError = false;
+    try {
+        // TODO: MI-203 - Support private schema endpoint
+        const config = await (0, openapi_core_1.loadConfig)();
+        const results = await (0, openapi_core_1.lint)({ ref: path, config });
+        results.forEach(result => {
+            const location = result.location.map(({ pointer, reportOnKey }) => ({
+                pointer,
+                reportOnKey,
+            }));
+            if (result.severity === 'warn') {
+                devkit_1.logger.warn(JSON.stringify({ location, message: result.message, severity: result.severity }));
+                return;
+            }
+            devkit_1.logger.error(JSON.stringify({ location, message: result.message, severity: result.severity }));
+            hasError = true;
+        });
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : 'Unknown error';
+        devkit_1.logger.error(`Failed to validate schema: ${message}`);
+        hasError = true;
+    }
+    return hasError;
+}

package/src/helpers/utilities.d.ts

@@ -0,0 +1,26 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Attempts to add a new project configuration to the workspace.
+ *
+ * This function adds a new project configuration to the workspace. If a project with the same name
+ * already exists, it returns `false`. If an error occurs for any other reason, the error is re-thrown.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} name - The name of the project to add.
+ * @param {string} projectRoot - The root directory of the project.
+ * @returns {boolean} `true` if the project configuration was added successfully, `false` if the project already exists.
+ * @throws {Error} If an error occurs that is not related to the project already existing.
+ */
+export declare function attemptToAddProjectConfiguration(tree: Tree, name: string, projectRoot: string): boolean;
+/**
+ * Adds a new path mapping to the `paths` property in the root TypeScript configuration file.
+ *
+ * This function updates the `tsconfig.base.json` or `tsconfig.json` file to include a new path mapping
+ * for the specified import path. If the import path already exists, an error is thrown.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} importPath - The import path to add to the `paths` property.
+ * @param {string[]} lookupPaths - The array of paths to associate with the import path.
+ * @throws {Error} If the import path already exists in the `paths` property.
+ */
+export declare function addTsConfigPath(tree: Tree, importPath: string, lookupPaths: string[]): void;

package/src/helpers/utilities.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attemptToAddProjectConfiguration = attemptToAddProjectConfiguration;
+exports.addTsConfigPath = addTsConfigPath;
+const devkit_1 = require("@nx/devkit");
+/**
+ * Attempts to add a new project configuration to the workspace.
+ *
+ * This function adds a new project configuration to the workspace. If a project with the same name
+ * already exists, it returns `false`. If an error occurs for any other reason, the error is re-thrown.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} name - The name of the project to add.
+ * @param {string} projectRoot - The root directory of the project.
+ * @returns {boolean} `true` if the project configuration was added successfully, `false` if the project already exists.
+ * @throws {Error} If an error occurs that is not related to the project already existing.
+ */
+function attemptToAddProjectConfiguration(tree, name, projectRoot) {
+    try {
+        (0, devkit_1.addProjectConfiguration)(tree, name, {
+            root: projectRoot,
+            projectType: 'library',
+            sourceRoot: `${projectRoot}/src`,
+            targets: {},
+            tags: ['client', name],
+        });
+        return true;
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('already exists')) {
+            return false;
+        }
+        throw err;
+    }
+}
+/**
+ * The utility functions below are only exported by '@nx/js', not '@nx/devkit'
+ * They're simple so we recreate them here instead of adding '@nx/js' as a dependency
+ * Source: {@link https://github.com/nrwl/nx/blob/master/packages/js/src/utils/typescript/ts-config.ts}
+ */
+function getRootTsConfigPathInTree(tree) {
+    for (const path of ['tsconfig.base.json', 'tsconfig.json']) {
+        if (tree.exists(path)) {
+            return path;
+        }
+    }
+    return 'tsconfig.base.json';
+}
+/**
+ * Adds a new path mapping to the `paths` property in the root TypeScript configuration file.
+ *
+ * This function updates the `tsconfig.base.json` or `tsconfig.json` file to include a new path mapping
+ * for the specified import path. If the import path already exists, an error is thrown.
+ *
+ * @param {Tree} tree - The file system tree representing the current project.
+ * @param {string} importPath - The import path to add to the `paths` property.
+ * @param {string[]} lookupPaths - The array of paths to associate with the import path.
+ * @throws {Error} If the import path already exists in the `paths` property.
+ */
+function addTsConfigPath(tree, importPath, lookupPaths) {
+    (0, devkit_1.updateJson)(tree, getRootTsConfigPathInTree(tree), json => {
+        json.compilerOptions ??= {};
+        const c = json.compilerOptions;
+        c.paths ??= {};
+        if (c.paths[importPath]) {
+            throw new Error(`You already have a library using the import path "${importPath}". Make sure to specify a unique one.`);
+        }
+        c.paths[importPath] = lookupPaths;
+        return json;
+    });
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from './generators/client/generator';

package/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* v8 ignore next 1 */
+__exportStar(require("./generators/client/generator"), exports);

package/src/types/openapi-typescript.d.ts

@@ -0,0 +1,12 @@
+declare module 'openapi-typescript' {
+    import type { Readable } from 'node:stream';
+    import { astToString, OpenAPI3, OpenAPITSOptions } from 'openapi-typescript/dist/index.js';
+    import ts from 'typescript';
+
+    export default function openapiTS(
+        source: string | URL | OpenAPI3 | Buffer | Readable,
+        options?: OpenAPITSOptions
+    ): Promise<ts.Node[]>;
+
+    export { astToString };
+}