@bitstack/ng-query-codegen-openapi 0.0.30

package/src/utils/factory.ts

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import semver from 'semver';
+
+const originalFactory = ts.factory;
+
+function createImportSpecifier(propertyName: ts.Identifier | undefined, name: ts.Identifier): ts.ImportSpecifier {
+  if (semver.satisfies(ts.version, '>= 4.5'))
+    // @ts-ignore
+    return originalFactory.createImportSpecifier(false, propertyName, name);
+  // @ts-ignore
+  return originalFactory.createImportSpecifier(propertyName, name);
+}
+
+function createExportSpecifier(
+  propertyName: string | ts.Identifier | undefined,
+  name: string | ts.Identifier
+): ts.ExportSpecifier {
+  if (semver.satisfies(ts.version, '>= 4.5'))
+    // @ts-ignore
+    return originalFactory.createExportSpecifier(false, propertyName, name);
+  // @ts-ignore
+  return originalFactory.createExportSpecifier(propertyName, name);
+}
+
+export const factory = {
+  ...originalFactory,
+  createImportSpecifier,
+  createExportSpecifier,
+};

package/src/utils/getOperationDefinitions.ts

@@ -0,0 +1,20 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { OperationDefinition } from '../types';
+import { operationKeys } from '../types';
+
+export function getOperationDefinitions(v3Doc: OpenAPIV3.Document): OperationDefinition[] {
+  return Object.entries(v3Doc.paths).flatMap(([path, pathItem]) =>
+    !pathItem
+      ? []
+      : Object.entries(pathItem)
+          .filter((arg): arg is [(typeof operationKeys)[number], OpenAPIV3.OperationObject] =>
+            operationKeys.includes(arg[0] as any)
+          )
+          .map(([verb, operation]) => ({
+            path,
+            verb,
+            pathItem,
+            operation,
+          }))
+  );
+}

package/src/utils/getV3Doc.ts

@@ -0,0 +1,24 @@
+import SwaggerParser from '@apidevtools/swagger-parser';
+import type { OpenAPIV3 } from 'openapi-types';
+// @ts-ignore
+import converter from 'swagger2openapi';
+
+export async function getV3Doc(
+  spec: string,
+  httpResolverOptions?: SwaggerParser.HTTPResolverOptions
+): Promise<OpenAPIV3.Document> {
+  const doc = await SwaggerParser.bundle(spec, {
+    resolve: {
+      http: httpResolverOptions,
+    },
+  });
+
+  const isOpenApiV3 = 'openapi' in doc && doc.openapi.startsWith('3');
+
+  if (isOpenApiV3) {
+    return doc as OpenAPIV3.Document;
+  } else {
+    const result = await converter.convertObj(doc, {});
+    return result.openapi as OpenAPIV3.Document;
+  }
+}

package/src/utils/http.ts

@@ -0,0 +1,86 @@
+import type {
+  EndpointMatcher, EndpointOverrides,
+  OperationDefinition,
+  ParameterDefinition,
+  ParameterMatcher,
+  TextMatcher,
+} from '../types';
+import {
+  getOperationName as _getOperationName,
+} from 'oazapfts/generate';
+
+
+/**
+ * 判斷 HTTP 狀態碼是否為成功的數據響應
+ */
+export function defaultIsDataResponse(code: string, includeDefault: boolean) {
+  if (includeDefault && code === 'default') {
+    return true;
+  }
+  const parsedCode = Number(code);
+  return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
+}
+
+/**
+ * 根據 HTTP 方法和路徑生成操作名稱
+ */
+export function getOperationName({ verb, path }: Pick<OperationDefinition, 'verb' | 'path'>) {
+  return _getOperationName(verb, path, undefined);
+}
+
+
+
+
+/**
+ * 從路徑項目中提取標籤（tags）
+ */
+export function getTags({ verb, pathItem }: Pick<OperationDefinition, 'verb' | 'pathItem'>): string[] {
+  return verb ? pathItem[verb]?.tags || [] : [];
+}
+
+/**
+ * 創建文本匹配器函數，用於過濾操作名稱
+ */
+function patternMatches(pattern?: TextMatcher) {
+  const filters = Array.isArray(pattern) ? pattern : [pattern];
+  return function matcher(operationName: string) {
+    if (!pattern) return true;
+    return filters.some((filter) =>
+      typeof filter === 'string' ? filter === operationName : filter?.test(operationName)
+    );
+  };
+}
+
+/**
+ * 創建操作匹配器函數，用於過濾操作定義
+ */
+export function operationMatches(pattern?: EndpointMatcher) {
+  const checkMatch = typeof pattern === 'function' ? pattern : patternMatches(pattern);
+  return function matcher(operationDefinition: OperationDefinition) {
+    if (!pattern) return true;
+    const operationName = getOperationName(operationDefinition);
+    return checkMatch(operationName, operationDefinition);
+  };
+}
+
+/**
+ * 創建參數匹配器函數，用於過濾參數定義
+ */
+export function argumentMatches(pattern?: ParameterMatcher) {
+  const checkMatch = typeof pattern === 'function' ? pattern : patternMatches(pattern);
+  return function matcher(argumentDefinition: ParameterDefinition) {
+    if (!pattern || argumentDefinition.in === 'path') return true;
+    const argumentName = argumentDefinition.name;
+    return checkMatch(argumentName, argumentDefinition);
+  };
+}
+
+/**
+ * 獲取操作的覆蓋配置
+ */
+export function getOverrides(
+  operation: OperationDefinition,
+  endpointOverrides?: EndpointOverrides[]
+): EndpointOverrides | undefined {
+  return endpointOverrides?.find((override) => operationMatches(override.pattern)(operation));
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export * from './capitalize';
+export * from './downloadSchema';
+export * from './getOperationDefinitions';
+export * from './getV3Doc';
+export * from './isQuery';
+export * from './isValidUrl';
+export * from './prettier';
+export * from './messages';
+export * from './removeUndefined';

package/src/utils/isQuery.ts

@@ -0,0 +1,16 @@
+import type { EndpointOverrides, operationKeys } from '../types';
+
+export function isQuery(
+  verb: (typeof operationKeys)[number],
+  path: string,
+  overrides: EndpointOverrides | undefined,
+  queryMatch?: (method: string, path: string) => boolean
+) {
+  if (queryMatch) {
+    return queryMatch(verb, path);
+  }
+  if (overrides?.type) {
+    return overrides.type === 'query';
+  }
+  return verb === 'get';
+}

package/src/utils/isValidUrl.ts

@@ -0,0 +1,9 @@
+export function isValidUrl(string: string) {
+  try {
+    new URL(string);
+  } catch (_) {
+    return false;
+  }
+
+  return true;
+}

package/src/utils/messages.ts

@@ -0,0 +1,7 @@
+export const MESSAGES = {
+  NAMED_EXPORT_MISSING: `You specified a named export that does not exist or was empty.`,
+  DEFAULT_EXPORT_MISSING: `Specified file exists, but no default export was found for the --baseQuery`,
+  FILE_NOT_FOUND: `Unable to locate the specified file provided to --baseQuery`,
+  TSCONFIG_FILE_NOT_FOUND: `Unable to locate the specified file provided to -c, --config`,
+  BASE_URL_IGNORED: `The url provided to --baseUrl is ignored when using --baseQuery`,
+};

package/src/utils/prettier.ts

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import prettier from 'prettier';
+import type { BuiltInParserName } from 'prettier';
+
+const EXTENSION_TO_PARSER: Record<string, BuiltInParserName> = {
+  ts: 'typescript',
+  tsx: 'typescript',
+  js: 'babel',
+  jsx: 'babel',
+  'js.flow': 'flow',
+  flow: 'flow',
+  gql: 'graphql',
+  graphql: 'graphql',
+  css: 'scss',
+  scss: 'scss',
+  less: 'scss',
+  stylus: 'scss',
+  markdown: 'markdown',
+  md: 'markdown',
+  json: 'json',
+};
+
+export async function prettify(filePath: string | null, content: string, prettierConfigFile?: string): Promise<string> {
+  let config = null;
+  let parser: BuiltInParserName = 'typescript';
+
+  try {
+    if (filePath) {
+      const fileExtension = path.extname(filePath).slice(1);
+      parser = EXTENSION_TO_PARSER[fileExtension] || 'typescript';
+      config = await prettier.resolveConfig(process.cwd(), {
+        useCache: true,
+        editorconfig: !prettierConfigFile,
+        config: prettierConfigFile,
+      });
+    } else if (prettierConfigFile) {
+      config = await prettier.resolveConfig(process.cwd(), {
+        useCache: true,
+        config: prettierConfigFile,
+      });
+    }
+
+    return prettier.format(content, {
+      parser,
+      ...config,
+    });
+  } catch (error) {
+    console.warn('Prettier formatting failed, returning original content:', error);
+    return content;
+  }
+}

package/src/utils/removeUndefined.ts

@@ -0,0 +1,3 @@
+export function removeUndefined<T>(t: T | undefined): t is T {
+  return typeof t !== 'undefined';
+}