feat: locate and read metadata from package.json

Author: bitgopatmcl

packages/openapi-generator/README.md

@@ -16,9 +16,13 @@ of the Typescript file passed as an input parameter. The OpenAPI specification w
 written to stdout.
 
 ```
+ARGUMENTS:
+  <file> - API route definition file
+
 OPTIONS:
-  --name, -n <str>     - API name [optional]
-  --version, -v <str>  - API version [optional]
+  --name, -n <str>       - API name [optional]
+  --version, -v <str>    - API version [optional]
+  --codec-file, -c <str> - Custom codec definition file [optional]
 
 FLAGS:
   --internal, -i - include routes marked private
@@ -30,3 +34,34 @@ For example:
 ```shell
 npx openapi-generator src/index.ts
 ```
+
+## Custom codec file
+
+`openapi-generator` only reads files in the specified package, and stops at the module
+boundary. This allows it to work even without `node_modules` installed. It has built-in
+support for `io-ts`, `io-ts-types`, and `@api-ts/io-ts-http` imports. If your package
+imports codecs from another external library, then you will have to define them in a
+custom configuration file so that `openapi-generator` will understand them. To do so,
+create a JS file with the following format:
+
+```typescript
+module.exports = (E) => {
+  return {
+    'io-ts-bigint': {
+      BigIntFromString: () => E.right({ type: 'primitive', value: 'string' }),
+      NonZeroBigInt: () => E.right({ type: 'primitive', value: 'number' }),
+      NonZeroBigIntFromString: () => E.right({ type: 'primitive', value: 'string' }),
+      NegativeBigIntFromString: () => E.right({ type: 'primitive', value: 'string' }),
+      NonNegativeBigIntFromString: () =>
+        E.right({ type: 'primitive', value: 'string' }),
+      PositiveBigIntFromString: () => E.right({ type: 'primitive', value: 'string' }),
+    },
+    // ... and so on for other packages
+  };
+};
+```
+
+The input parameter `E` is the namespace import of `fp-ts/Either` (so that trying to
+`require` it from the config file isn't an issue), and the return type is a `Record`
+containing AST definitions for external libraries.
+[Refer to KNOWN_IMPORTS here for info on the structure](./src/knownImports.ts)

packages/openapi-generator/src/cli.ts

@@ -19,6 +19,7 @@ import { getRefs } from './ref';
 import { convertRoutesToOpenAPI } from './openapi';
 import type { Route } from './route';
 import type { Schema } from './ir';
+import { getPackageJsonPath } from './packageInfo';
 import { Project } from './project';
 import { KNOWN_IMPORTS } from './knownImports';
 import { findSymbolInitializer } from './resolveInit';
@@ -33,34 +34,16 @@ const app = command({
       displayName: 'file',
     }),
     name: option({
-      type: string,
+      type: optional(string),
       description: 'API name',
       long: 'name',
       short: 'n',
-      defaultValue: () => {
-        const pkgFile = p.join(process.cwd(), 'package.json');
-        try {
-          const pkgJson = fs.readFileSync(pkgFile, 'utf-8');
-          return JSON.parse(pkgJson)['name'] ?? 'openapi-generator';
-        } catch (err) {
-          return 'openapi-generator';
-        }
-      },
     }),
     version: option({
-      type: string,
+      type: optional(string),
       description: 'API version',
       long: 'version',
       short: 'v',
-      defaultValue: () => {
-        const pkgFile = p.join(process.cwd(), 'package.json');
-        try {
-          const pkgJson = fs.readFileSync(pkgFile, 'utf-8');
-          return JSON.parse(pkgJson)['version'] ?? '0.0.1';
-        } catch (err) {
-          return '0.0.1';
-        }
-      },
     }),
     includeInternal: flag({
       type: boolean,
@@ -74,12 +57,35 @@ const app = command({
       description: 'Custom codec definition file',
       long: 'codec-file',
       short: 'c',
-      defaultValue: () => undefined,
     }),
   },
-  handler: async ({ input, name, version, codecFile }) => {
+  handler: async ({
+    input,
+    name: nameParam,
+    version: versionParam,
+    codecFile: codecFileParam,
+  }) => {
     const filePath = p.resolve(input);
 
+    const packageJsonPath = await getPackageJsonPath(filePath);
+    let packageJson: Record<string, any> = {};
+    if (packageJsonPath !== undefined) {
+      packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    }
+
+    const name = nameParam ?? packageJson['name'] ?? 'openapi-generator';
+    const version = versionParam ?? packageJson['version'] ?? '0.0.1';
+
+    let codecFile: string | undefined = codecFileParam;
+    if (
+      codecFileParam === undefined &&
+      packageJsonPath !== undefined &&
+      packageJson['openapi-generator']?.['codec-file'] !== undefined
+    ) {
+      const relativeCodecFilePath = packageJson['openapi-generator']['codec-file'];
+      codecFile = p.join(p.dirname(packageJsonPath), relativeCodecFilePath);
+    }
+
     let knownImports = KNOWN_IMPORTS;
     if (codecFile !== undefined) {
       const codecFilePath = p.resolve(codecFile);

packages/openapi-generator/src/packageInfo.ts

@@ -0,0 +1,30 @@
+import * as fs from 'fs/promises';
+import * as p from 'path';
+
+export async function getPackageJsonPath(
+  entryPoint: string,
+): Promise<string | undefined> {
+  let dir = p.dirname(entryPoint);
+  while (dir !== '/') {
+    const pkgJsonPath = p.join(dir, 'package.json');
+    try {
+      const pkgJson = await fs.stat(pkgJsonPath);
+      if (pkgJson !== undefined) {
+        return pkgJsonPath;
+      }
+    } catch (e: any) {
+      if (e.code === 'ENOENT') {
+        const parentDir = p.dirname(dir);
+        if (parentDir === dir) {
+          // This is the root directory
+          break;
+        }
+        dir = parentDir;
+        continue;
+      } else {
+        throw e;
+      }
+    }
+  }
+  return undefined;
+}