@zimic/http 0.0.1-canary.2

package/src/typegen/openapi/transform/context.ts

@@ -0,0 +1,67 @@
+import { convertToPascalCase } from '@/utils/strings';
+
+import { parseRawFilter, groupParsedFiltersByMatch } from './filters';
+
+export interface TypePathFilters {
+  positive: RegExp[];
+  negative: RegExp[];
+}
+
+type HttpTypeImportName =
+  | 'HttpSchema'
+  | 'HttpFormData'
+  | 'HttpFormDataSerialized'
+  | 'HttpSearchParams'
+  | 'HttpSearchParamsSerialized'
+  | 'HttpHeadersSerialized'
+  | 'HttpStatusCode'
+  | 'MergeHttpResponsesByStatusCode';
+
+type OperationName = string;
+export type OperationPath = OperationName;
+
+export type ComponentGroupName = string;
+export type ComponentName = string;
+export type ComponentPath = `${ComponentGroupName}.${ComponentName}`;
+
+export interface TypeTransformContext {
+  serviceName: string;
+  filters: {
+    paths: TypePathFilters;
+  };
+  typeImports: {
+    http: Set<HttpTypeImportName>;
+  };
+  referencedTypes: {
+    operations: Set<OperationPath>;
+    components: Set<ComponentPath>;
+  };
+  pendingActions: {
+    components: {
+      requests: { toMarkBodyAsOptional: Set<ComponentName> };
+    };
+  };
+}
+
+export function createTypeTransformationContext(serviceName: string, rawFilters: string[]): TypeTransformContext {
+  const parsedFilters = rawFilters.map(parseRawFilter);
+
+  return {
+    serviceName: convertToPascalCase(serviceName),
+    filters: {
+      paths: groupParsedFiltersByMatch(parsedFilters),
+    },
+    typeImports: {
+      http: new Set(),
+    },
+    referencedTypes: {
+      operations: new Set(),
+      components: new Set(),
+    },
+    pendingActions: {
+      components: {
+        requests: { toMarkBodyAsOptional: new Set() },
+      },
+    },
+  };
+}

package/src/typegen/openapi/transform/filters.ts

@@ -0,0 +1,71 @@
+import chalk from 'chalk';
+import filesystem from 'fs/promises';
+import path from 'path';
+
+import { HTTP_METHODS } from '@/types/schema';
+import { logWithPrefix } from '@/utils/console';
+import { isNonEmpty } from '@/utils/data';
+import { createRegexFromWildcardPath } from '@/utils/urls';
+
+import { TypePathFilters } from './context';
+
+const HTTP_METHOD_OPTIONS = HTTP_METHODS.join('|');
+const MODIFIER_GROUP = '(?<modifier>!?)';
+const METHOD_FILTER_GROUP = `(?<method>(?:\\*|(?:${HTTP_METHOD_OPTIONS})(?:,\\s*(?:${HTTP_METHOD_OPTIONS}))*))`;
+const PATH_FILTER_GROUP = '(?<path>.+)';
+const FILTER_REGEX = new RegExp(`^${MODIFIER_GROUP}\\s*${METHOD_FILTER_GROUP}\\s+${PATH_FILTER_GROUP}$`, 'i');
+
+interface ParsedTypePathFilter {
+  expression: RegExp;
+  isNegativeMatch: boolean;
+}
+
+export function parseRawFilter(rawFilter: string): ParsedTypePathFilter | undefined {
+  const filterMatch = rawFilter.match(FILTER_REGEX);
+  const { modifier: filterModifier, method: filteredMethodsOrWildcard, path: filteredPath } = filterMatch?.groups ?? {};
+
+  const isValidFilter = !filteredMethodsOrWildcard || !filteredPath;
+  if (isValidFilter) {
+    logWithPrefix(`Warning: Filter could not be parsed and was ignored: ${chalk.yellow(rawFilter)}`, {
+      method: 'warn',
+    });
+    return undefined;
+  }
+
+  const methodFilterGroup = `(?:${filteredMethodsOrWildcard.toUpperCase().replace(/,/g, '|').replace(/\*/g, '.*')}) `;
+  const isNegativeMatch = filterModifier === '!';
+
+  return {
+    expression: createRegexFromWildcardPath(filteredPath, { prefix: methodFilterGroup }),
+    isNegativeMatch,
+  };
+}
+
+export function groupParsedFiltersByMatch(parsedFilters: (ParsedTypePathFilter | undefined)[]) {
+  return parsedFilters.reduce<TypePathFilters>(
+    (groupedFilters, filter) => {
+      if (filter) {
+        if (filter.isNegativeMatch) {
+          groupedFilters.negative.push(filter.expression);
+        } else {
+          groupedFilters.positive.push(filter.expression);
+        }
+      }
+
+      return groupedFilters;
+    },
+    { positive: [], negative: [] },
+  );
+}
+
+export async function readPathFiltersFromFile(filePath: string) {
+  const fileContent = await filesystem.readFile(path.resolve(filePath), 'utf-8');
+  const fileContentWithoutComments = fileContent.replace(/#.*$/gm, '');
+
+  const filters = fileContentWithoutComments.split('\n');
+  return filters;
+}
+
+export function ignoreEmptyFilters(filters: string[]) {
+  return filters.map((line) => line.trim()).filter(isNonEmpty);
+}

package/src/typegen/openapi/transform/imports.ts

@@ -0,0 +1,15 @@
+import { createImportDeclaration, createImportSpecifier } from '../utils/types';
+import { TypeTransformContext } from './context';
+
+/* istanbul ignore next -- @preserve
+ * The root import module is defined at build time. The fallback is not expected to be used. */
+export const TYPEGEN_HTTP_IMPORT_MODULE = process.env.TYPEGEN_HTTP_IMPORT_MODULE ?? '@zimic/http';
+
+export function createImportDeclarations(context: TypeTransformContext) {
+  const httpTypeImports = Array.from(context.typeImports.http).sort().map(createImportSpecifier);
+  const httpImportDeclaration = createImportDeclaration(httpTypeImports, TYPEGEN_HTTP_IMPORT_MODULE, {
+    typeOnly: true,
+  });
+
+  return [httpImportDeclaration];
+}

package/src/typegen/openapi/transform/io.ts

@@ -0,0 +1,86 @@
+import type { SchemaObject } from 'openapi-typescript';
+import path from 'path';
+import ts from 'typescript';
+
+import { createCachedDynamicImport } from '@/utils/imports';
+import { createFileURL, createURL } from '@/utils/urls';
+
+import { createBlobType, createNullType } from '../utils/types';
+
+const importOpenapiTypeScript = createCachedDynamicImport(() => import('openapi-typescript'));
+
+function transformSchemaObject(schemaObject: SchemaObject) {
+  if (schemaObject.format === 'binary') {
+    const blobType = createBlobType();
+
+    if (schemaObject.nullable) {
+      const nullType = createNullType();
+      return ts.factory.createUnionTypeNode([blobType, nullType]);
+    }
+
+    return blobType;
+  }
+}
+
+function convertFilePathOrURLToURL(filePathOrURL: string) {
+  try {
+    return createURL(filePathOrURL);
+  } catch {
+    return createFileURL(path.resolve(filePathOrURL));
+  }
+}
+
+export async function importTypesFromOpenAPI(filePathOrURL: string) {
+  const schemaURL = convertFilePathOrURLToURL(filePathOrURL);
+
+  const { default: generateTypesFromOpenAPI } = await importOpenapiTypeScript();
+
+  const rawNodes = await generateTypesFromOpenAPI(schemaURL, {
+    alphabetize: false,
+    additionalProperties: false,
+    excludeDeprecated: false,
+    propertiesRequiredByDefault: false,
+    defaultNonNullable: true,
+    pathParamsAsTypes: false,
+    emptyObjectsUnknown: true,
+    exportType: false,
+    arrayLength: false,
+    immutable: false,
+    enumValues: false,
+    enum: false,
+    silent: true,
+    transform: transformSchemaObject,
+  });
+
+  return rawNodes;
+}
+
+export async function convertTypesToString(nodes: ts.Node[], options: { includeComments: boolean }) {
+  const { astToString: convertTypeASTToString } = await importOpenapiTypeScript();
+
+  const typeOutput = convertTypeASTToString(nodes, {
+    formatOptions: { removeComments: !options.includeComments },
+  });
+
+  return typeOutput;
+}
+
+export function prepareTypeOutputToSave(output: string) {
+  const formattedOutput = output
+    .replace(/^export (\w+)/gm, '\nexport $1')
+    .replace(/^( {4})+/gm, (match) => match.replace(/ {4}/g, '  '));
+
+  const formattedOutputWithPrefix = [
+    '// Auto-generated by zimic.',
+    '// NOTE: Do not manually edit this file. Changes will be overridden.\n',
+    formattedOutput,
+  ].join('\n');
+
+  return formattedOutputWithPrefix;
+}
+
+export async function writeTypeOutputToStandardOutput(formattedOutput: string) {
+  await new Promise((resolve) => {
+    process.stdout.write(formattedOutput, 'utf-8', resolve);
+  });
+}