@openapi-qraft/plugin 1.8.0

package/src/lib/open-api/getServices.ts

@@ -0,0 +1,208 @@
+import camelCase from 'camelcase';
+import * as console from 'console';
+import micromatch from 'micromatch';
+
+import { getContentMediaType } from './getContent.js';
+import { getOperationName } from './getOperationName.js';
+import {
+  getServiceNamesByOperationEndpoint,
+  ServiceBaseNameByEndpointOption,
+} from './getServiceNamesByOperationEndpoint.js';
+import { getServiceNamesByOperationTags } from './getServiceNamesByOperationTags.js';
+import type { OpenAPISchemaType } from './OpenAPISchemaType.js';
+
+export type ServiceBaseName = ServiceBaseNameByEndpointOption | 'tags';
+
+/**
+ * @deprecated move to separate file
+ */
+export type Service = {
+  name: string;
+  variableName: string;
+  typeName: string;
+  fileBaseName: string;
+  operations: ServiceOperation[];
+};
+
+/**
+ * @deprecated move to separate file
+ */
+export type ServiceOperation = {
+  method:
+    | 'get'
+    | 'put'
+    | 'post'
+    | 'patch'
+    | 'delete'
+    | 'options'
+    | 'head'
+    | 'trace';
+  path: string;
+  name: string;
+  description: string | undefined;
+  summary: string | undefined;
+  deprecated: boolean | undefined;
+  mediaType: string | undefined;
+  errors: Record<string, string | undefined>;
+  success: Record<string, string | undefined>;
+  parameters: Record<string, any> | undefined;
+};
+
+export interface ServiceOutputOptions {
+  postfixServices?: string; // todo::rename to `postfixService`
+  serviceNameBase?: ServiceBaseName;
+}
+
+export const getServices = (
+  openApiJson: OpenAPISchemaType,
+  {
+    postfixServices = 'Service',
+    serviceNameBase = 'endpoint[0]',
+  }: ServiceOutputOptions = {},
+  servicesGlob = ['**']
+) => {
+  const paths = openApiJson.paths;
+
+  const services = new Map<string, Service>();
+
+  const isPathMatch = createServicePathMatch(servicesGlob);
+
+  for (const path in paths) {
+    if (!Object.prototype.hasOwnProperty.call(paths, path)) continue;
+
+    for (const method in paths[path]) {
+      if (!Object.prototype.hasOwnProperty.call(paths[path], method)) continue;
+      if (!isPathMatch(path)) continue;
+
+      if (!supportedMethod(method)) {
+        console.warn(
+          `The path "${path}" HTTP method "${method}" is not supported`
+        );
+        continue;
+      }
+
+      const methodOperation = paths[path][method];
+
+      const { success, errors } = Object.entries(
+        methodOperation.responses
+      ).reduce(
+        (acc, [statusCode, response]) => {
+          if (!response.content || typeof response.content !== 'object') {
+            return acc;
+          }
+
+          const statusType =
+            statusCode !== 'default' && // See "default" response https://swagger.io/docs/specification/describing-responses/#default
+            Number(statusCode) < 400
+              ? 'success'
+              : 'errors';
+
+          return {
+            ...acc,
+            [statusType]: {
+              ...acc[statusType],
+              [statusCode]: getContentMediaType(response.content),
+            },
+          };
+        },
+        {} as Record<'errors' | 'success', Record<string, string | undefined>>
+      );
+
+      const serviceFallbackBaseName = 'Default';
+
+      const serviceNames =
+        serviceNameBase === 'tags'
+          ? getServiceNamesByOperationTags(
+              paths[path][method]?.tags,
+              serviceFallbackBaseName
+            )
+          : getServiceNamesByOperationEndpoint(
+              path,
+              serviceNameBase,
+              serviceFallbackBaseName
+            );
+
+      for (const name of serviceNames) {
+        if (!services.has(name)) {
+          services.set(name, {
+            name: camelCase(name),
+            variableName: `${camelCase(name, {
+              preserveConsecutiveUppercase: false,
+            })}${postfixServices}`,
+            typeName: `${name}${postfixServices}`,
+            fileBaseName: `${name}${postfixServices}`,
+            operations: [],
+          });
+        }
+      }
+
+      for (const name of serviceNames) {
+        services.get(name)!.operations.push({
+          method,
+          path,
+          errors,
+          name: getOperationName(path, method, methodOperation.operationId),
+          description: methodOperation.description,
+          summary: methodOperation.summary,
+          deprecated: methodOperation.deprecated,
+          parameters:
+            Array.isArray(methodOperation.parameters) &&
+            !methodOperation.parameters.length
+              ? undefined
+              : methodOperation.parameters,
+          mediaType: methodOperation.requestBody?.content
+            ? getContentMediaType(methodOperation.requestBody.content)
+            : undefined,
+          success: success,
+        });
+      }
+    }
+  }
+
+  return Array.from(services.values());
+};
+
+/**
+ * Create a function to match service paths
+ * @param servicesGlob
+ */
+export const createServicePathMatch = (servicesGlob: string[]) => {
+  const servicePathGlobs = servicesGlob.reduce<
+    Record<'match' | 'ignore', string[]>
+  >(
+    (acc, glob) => {
+      glob.startsWith('!')
+        ? acc.ignore.push(glob.slice(1))
+        : acc.match.push(glob);
+      return acc;
+    },
+    {
+      match: [],
+      ignore: [],
+    }
+  );
+
+  return function isServicePatchMatch(path: string) {
+    return micromatch.isMatch(path, servicePathGlobs.match, {
+      ignore: servicePathGlobs.ignore,
+    });
+  };
+};
+
+export const supportedMethod = (
+  method: unknown
+): method is (typeof supportedHTTPMethods)[number] =>
+  supportedHTTPMethods.includes(
+    method as (typeof supportedHTTPMethods)[number]
+  );
+
+const supportedHTTPMethods = Object.values({
+  get: 'get',
+  put: 'put',
+  post: 'post',
+  patch: 'patch',
+  delete: 'delete',
+  options: 'options',
+  head: 'head',
+  trace: 'trace',
+} satisfies { [key in ServiceOperation['method']]: key });

package/src/lib/open-api/readSchema.ts

@@ -0,0 +1,27 @@
+import { createConfig } from '@redocly/openapi-core';
+
+import type { Readable } from 'node:stream';
+import type { OpenAPI3 } from 'openapi-typescript';
+import { validateAndBundle } from 'openapi-typescript/dist/lib/redoc.js';
+
+import { OpenAPISchemaType } from './OpenAPISchemaType.js';
+
+export const readSchema = async (
+  source: string | URL | OpenAPI3 | Readable | Buffer
+) => {
+  const redoc = await createConfig(
+    {
+      rules: {
+        'operation-operationId-unique': { severity: 'error' }, // throw error on duplicate operationIDs
+      },
+    },
+    { extends: ['minimal'] }
+  );
+
+  const parsed = await validateAndBundle(source, {
+    redoc,
+    silent: false,
+  });
+
+  return parsed as OpenAPISchemaType;
+};

package/src/lib/writeGeneratorFiles.ts

@@ -0,0 +1,83 @@
+import c from 'ansi-colors';
+import fs from 'node:fs';
+import { Ora } from 'ora';
+
+import { GeneratorFile } from './GeneratorFile.js';
+
+export const writeGeneratorFiles = async ({
+  spinner,
+  fileItems,
+}: {
+  spinner: Ora;
+  fileItems: GeneratorFile[];
+}) => {
+  await setupDirectories(spinner, fileItems);
+  await writeFiles(spinner, fileItems);
+};
+
+const setupDirectories = async (spinner: Ora, fileItems: GeneratorFile[]) => {
+  for (const fileItem of fileItems) {
+    if (!('directory' in fileItem)) continue;
+
+    if (fileItem.clean) {
+      spinner.text = `Cleaning ${c.magenta(fileItem.directory.pathname)}`;
+
+      try {
+        await fs.promises.rm(fileItem.directory, {
+          recursive: true,
+          force: true,
+        });
+      } catch (error) {
+        spinner.fail(
+          c.redBright(
+            `Error occurred during ${c.magenta(
+              fileItem.directory.pathname
+            )} directory cleaning`
+          )
+        );
+
+        throw error;
+      }
+    }
+
+    try {
+      spinner.text = `Creating directory ${c.magenta(fileItem.directory.pathname)}`;
+
+      await fs.promises.mkdir(fileItem.directory, { recursive: true });
+    } catch (error) {
+      spinner.fail(
+        c.redBright(
+          `Error occurred during ${c.magenta(
+            fileItem.directory.pathname
+          )} directory creation`
+        )
+      );
+
+      throw error;
+    }
+  }
+};
+
+const writeFiles = async (spinner: Ora, fileItems: GeneratorFile[]) => {
+  for (const fileItem of fileItems) {
+    if ('directory' in fileItem) continue;
+
+    const { file, code } = fileItem;
+
+    spinner.text = `Writing ${c.magenta(file.pathname)}`;
+
+    try {
+      await fs.promises.writeFile(file, code, {
+        encoding: 'utf-8',
+      });
+    } catch (error) {
+      spinner.fail(
+        c.redBright(
+          `Error occurred during ${c.magenta(file.pathname)} file writing`
+        )
+      );
+
+      throw error;
+    }
+  }
+};