swagger-typescript-api 13.0.0-experimental-1 → 13.0.0

package/index.d.ts

@@ -1,3 +1,5 @@
+import {MonoSchemaParser} from "./src/schema-parser/mono-schema-parser";
+
 type HttpClientType = "axios" | "fetch";
 
 interface GenerateApiParamsBase {
@@ -7,7 +9,7 @@ interface GenerateApiParamsBase {
   name?: string;
 
   /**
-   * path to folder where will been located the created api module.
+   * path to folder where will be located the created api module.
    *
    * may set to `false` to skip writing content to disk. in this case,
    * you may access the `files` on the return value.
@@ -54,6 +56,16 @@ interface GenerateApiParamsBase {
    */
   unwrapResponseData?: boolean;
 
+  /**
+   * sort data contracts in alphabetical order
+   */
+  sortTypes?: boolean;
+
+  /**
+   * sort routes in alphabetical order
+   */
+  sortRoutes?: boolean;
+
   /**
    * generate js api module with declaration file (default: false)
    */
@@ -139,22 +151,79 @@ interface GenerateApiParamsBase {
 
   /** extract all enums from nested types\interfaces to `enum` construction */
   extractEnums?: boolean;
+
   /** prefix string value needed to fix invalid type names (default: 'Type') */
   fixInvalidTypeNamePrefix?: string;
+
   /** prefix string value needed to fix invalid enum keys (default: 'Value') */
   fixInvalidEnumKeyPrefix?: string;
+
   /** prefix string value for enum keys */
   enumKeyPrefix?: string;
+
   /** suffix string value for enum keys */
   enumKeySuffix?: string;
+
   /** prefix string value for type names */
   typePrefix?: string;
+
   /** suffix string value for type names */
   typeSuffix?: string;
+
   /** extra configuration for extracting type names operations */
   extractingOptions?: Partial<ExtractingOptions>;
+
   /** configuration for fetching swagger schema requests */
   requestOptions?: null | Partial<import("node-fetch").RequestInit>;
+
+  /** ts compiler configuration object (for --to-js option) */
+  compilerTsConfig?: Record<string, any>;
+
+  /**
+   * custom ts->* translator
+   * do not use constructor args, it can break functionality of this property, just send class reference
+   *
+   * @example
+   * ```ts
+   * const { Translator } = require("swagger-typescript-api/src/translators/translator");
+   *
+   * class MyTranslator extends Translator {
+   *
+   *     translate({ fileName, fileExtension, fileContent }) {
+   *         this.codeFormatter.format()
+   *         this.config.
+   *         this.logger.
+   *
+   *         return [
+   *             {
+   *                 fileName,
+   *                 fileExtension,
+   *                 fileContent,
+   *             }
+   *         ]
+   *     }
+   * }
+   * ```
+   */
+  customTranslator?: new () => typeof import("./src/translators/translator").Translator;
+  /** fallback name for enum key resolver */
+  enumKeyResolverName?: string;
+  /** fallback name for type name resolver */
+  typeNameResolverName?: string;
+  /** fallback name for specific arg name resolver */
+  specificArgNameResolverName?: string;
+  schemaParsers?: {
+    complexOneOf?:MonoSchemaParser;
+    complexAllOf?:MonoSchemaParser;
+    complexAnyOf?:MonoSchemaParser;
+    complexNot?:MonoSchemaParser;
+    enum?:MonoSchemaParser;
+    object?:MonoSchemaParser;
+    complex?:MonoSchemaParser;
+    primitive?:MonoSchemaParser;
+    discriminator?:MonoSchemaParser;
+    array?: MonoSchemaParser;
+  }
 }
 
 type CodeGenConstruct = {
@@ -201,7 +270,7 @@ type CodeGenConstruct = {
 
 type PrimitiveTypeStructValue =
   | string
-  | ((schema: Record<string, any>, parser: import("./src/schema-parser/schema-processor").SchemaProcessor) => string);
+  | ((schema: Record<string, any>, parser: import("./src/schema-parser/schema-parser").SchemaParser) => string);
 
 type PrimitiveTypeStruct = Record<
   "integer" | "number" | "boolean" | "object" | "file" | "string" | "array",
@@ -269,7 +338,10 @@ export interface Hooks {
   /** calls after parse route (return type: customized route (ParsedRoute), nothing change (void), false (ignore this route)) */
   onCreateRoute: (routeData: ParsedRoute) => ParsedRoute | void | false;
   /** Start point of work this tool (after fetching schema) */
-  onInit?: <C extends GenerateApiConfiguration["config"]>(configuration: C) => C | void;
+  onInit?: <C extends GenerateApiConfiguration["config"]>(
+    configuration: C,
+    codeGenProcess: import("./src/code-gen-process").CodeGenProcess,
+  ) => C | void;
   /** customize configuration object before sending it to ETA templates */
   onPrepareConfig?: <C extends GenerateApiConfiguration>(currentConfiguration: C) => C | void;
   /** customize route name as you need */
@@ -354,7 +426,7 @@ export interface SchemaComponent {
     };
     $parsed: ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent>;
   };
-  componentName: string;
+  componentName: "schemas" | "paths";
   typeData: ParsedSchema<SchemaTypeObjectContent | SchemaTypeEnumContent | SchemaTypePrimitiveContent> | null;
 }
 
@@ -430,10 +502,16 @@ type ExtractingOptions = {
   responseBodySuffix: string[];
   responseErrorSuffix: string[];
   requestParamsSuffix: string[];
+  enumSuffix: string[];
+  discriminatorMappingSuffix: string[];
+  discriminatorAbstractPrefix: string[];
   requestBodyNameResolver: (name: string, reservedNames: string) => string | undefined;
   responseBodyNameResolver: (name: string, reservedNames: string) => string | undefined;
   responseErrorNameResolver: (name: string, reservedNames: string) => string | undefined;
   requestParamsNameResolver: (name: string, reservedNames: string) => string | undefined;
+  enumNameResolver: (name: string, reservedNames: string) => string | undefined;
+  discriminatorMappingNameResolver: (name: string, reservedNames: string) => string | undefined;
+  discriminatorAbstractResolver: (name: string, reservedNames: string) => string | undefined;
 };
 
 export interface GenerateApiConfiguration {
@@ -450,6 +528,18 @@ export interface GenerateApiConfiguration {
     url: string;
     spec: any;
     fileName: string;
+    templatePaths: {
+      /** `templates/base` */
+      base: string;
+      /** `templates/default` */
+      default: string;
+      /** `templates/modular` */
+      modular: string;
+      /** usage path if `--templates` option is not set */
+      original: string;
+      /** custom path to templates (`--templates`) */
+      custom: string | null;
+    };
     authorizationToken?: string;
     generateResponses: boolean;
     defaultResponseAsSuccess: boolean;
@@ -468,6 +558,7 @@ export interface GenerateApiConfiguration {
     extractRequestParams: boolean;
     unwrapResponseData: boolean;
     sortTypes: boolean;
+    sortRoutes: boolean;
     singleHttpClient: boolean;
     typePrefix: string;
     typeSuffix: string;
@@ -492,10 +583,16 @@ export interface GenerateApiConfiguration {
     hooks: Hooks;
     enumNamesAsValues: boolean;
     version: string;
+    compilerTsConfig: Record<string, any>;
+    enumKeyResolverName: string;
+    typeNameResolverName: string;
+    specificArgNameResolverName: string;
+    /** do not use constructor args, it can break functionality of this property, just send class reference */
+    customTranslator?: new (...args: never[]) => typeof import("./src/translators/translator").Translator;
     internalTemplateOptions: {
       addUtilRequiredKeysType: boolean;
     };
-    componentTypeNameResolver: typeof import("./src/util/name-resolver").ComponentTypeNameResolver;
+    componentTypeNameResolver: typeof import("./src/component-type-name-resolver").ComponentTypeNameResolver;
     fileNames: {
       dataContracts: string;
       routeTypes: string;
@@ -520,7 +617,6 @@ export interface GenerateApiConfiguration {
     extractingOptions: ExtractingOptions;
   };
   modelTypes: ModelType[];
-  rawModelTypes: SchemaComponent[];
   hasFormDataRoutes: boolean;
   hasSecurityRoutes: boolean;
   hasQueryRoutes: boolean;
@@ -556,9 +652,18 @@ export interface GenerateApiConfiguration {
   };
 }
 
+type FileInfo = {
+  /** @example myFilename */
+  fileName: string;
+  /** @example .d.ts */
+  fileExtension: string;
+  /** content of the file */
+  fileContent: string;
+};
+
 export interface GenerateApiOutput {
   configuration: GenerateApiConfiguration;
-  files: { name: string; content: string; declaration: { name: string; content: string } | null }[];
+  files: FileInfo[];
   createFile: (params: { path: string; fileName: string; content: string; withPrefix?: boolean }) => void;
   renderTemplate: (
     templateContent: string,
@@ -566,7 +671,7 @@ export interface GenerateApiOutput {
     etaOptions?: import("eta/dist/types/config").PartialConfig,
   ) => string;
   getTemplate: (params: { fileName?: string; name?: string; path?: string }) => string;
-  formatTSContent: (content: string) => string;
+  formatTSContent: (content: string) => Promise<string>;
 }
 
 export declare function generateApi(params: GenerateApiParams): Promise<GenerateApiOutput>;