swagger-typescript-api 13.2.8 → 13.2.10

package/dist/lib.d.ts

@@ -1,7 +1,5 @@
-import * as lodash0$1 from "lodash";
 import * as lodash0 from "lodash";
 import lodash from "lodash";
-import * as typescript$1 from "typescript";
 import * as typescript from "typescript";
 import * as eta0 from "eta";
 import { OpenAPI } from "openapi-types";
@@ -379,7 +377,7 @@ declare class JavascriptTranslator extends Translator {
   compileTSCode: (input: TranslatorIO) => Record<string, string>;
   translate: (input: any) => Promise<{
     fileName: any;
-    fileExtension: typescript$1.Extension;
+    fileExtension: typescript.Extension;
     fileContent: string;
   }[]>;
 }
@@ -528,7 +526,7 @@ declare class CodeGenProcess {
         }) => string;
         NameResolver: typeof NameResolver;
         _: lodash.LoDashStatic;
-        require: (packageOrPath: string) => Promise<any>;
+        require: (packageOrPath: string) => any;
       };
     };
     getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
@@ -633,7 +631,7 @@ declare class CodeGenProcess {
       }) => string;
       NameResolver: typeof NameResolver;
       _: lodash.LoDashStatic;
-      require: (packageOrPath: string) => Promise<any>;
+      require: (packageOrPath: string) => any;
     };
     config: CodeGenConfig;
   };
@@ -670,7 +668,7 @@ declare class TemplatesWorker {
   getTemplatePaths: (config: CodeGenConfig) => CodeGenConfig["templatePaths"];
   cropExtension: (path: string) => string;
   getTemplateFullPath: (path_: string, fileName: string) => string | undefined;
-  requireFnFromTemplate: (packageOrPath: string) => Promise<any>;
+  requireFnFromTemplate: (packageOrPath: string) => any;
   getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
   getTemplates: ({
     templatePaths
@@ -774,6 +772,73 @@ declare class MonoSchemaParser {
 //#endregion
 //#region types/index.d.ts
 type HttpClientType = (typeof HTTP_CLIENT)[keyof typeof HTTP_CLIENT];
+type CodeGenConstruct = {
+  Keyword: {
+    Number: string;
+    String: string;
+    Boolean: string;
+    Any: string;
+    Void: string;
+    Unknown: string;
+    Null: string;
+    Undefined: string;
+    Object: string;
+    File: string;
+    Date: string;
+    Type: string;
+    Enum: string;
+    Interface: string;
+    Array: string;
+    Record: string;
+    Intersection: string;
+    Union: string;
+  };
+  CodeGenKeyword: {
+    UtilRequiredKeys: string;
+  };
+  ArrayType: (content: unknown) => string;
+  StringValue: (content: unknown) => string;
+  BooleanValue: (content: unknown) => string;
+  NumberValue: (content: unknown) => string;
+  NullValue: (content: unknown) => string;
+  UnionType: (content: unknown) => string;
+  ExpressionGroup: (content: unknown) => string;
+  IntersectionType: (content: unknown) => string;
+  RecordType: (content: unknown) => string;
+  TypeField: (content: unknown) => string;
+  InterfaceDynamicField: (content: unknown) => string;
+  EnumUsageKey: (enumStruct: unknown, key: unknown) => string;
+  EnumField: (content: unknown) => string;
+  EnumFieldDescription: (content: unknown) => string;
+  EnumFieldsWrapper: (content: unknown) => string;
+  ObjectWrapper: (content: unknown) => string;
+  MultilineComment: (content: unknown) => string;
+  TypeWithGeneric: (content: unknown) => string;
+  Tuple: (content: unknown) => string;
+};
+type PrimitiveTypeStructValue = string | ((schema: Record<string, unknown>, parser: SchemaParser) => string);
+type PrimitiveTypeStruct = Record<"integer" | "number" | "boolean" | "object" | "file" | "string" | "array", string | ({
+  $default: PrimitiveTypeStructValue;
+} & Record<string, PrimitiveTypeStructValue>)>;
+interface GenerateApiParamsFromPath extends Partial<GenerateApiConfiguration["config"]> {
+  /**
+   * path to swagger schema
+   */
+  input: string;
+}
+interface GenerateApiParamsFromUrl extends Partial<GenerateApiConfiguration["config"]> {
+  /**
+   * url to swagger schema
+   */
+  url: string;
+}
+interface GenerateApiParamsFromSpecLiteral extends Partial<GenerateApiConfiguration["config"]> {
+  /**
+   * swagger schema JSON
+   */
+  spec: swagger_schema_official0.Spec;
+}
+type GenerateApiParams = GenerateApiParamsFromPath | GenerateApiParamsFromUrl | GenerateApiParamsFromSpecLiteral;
 type BuildRouteParam = {
   /** {bar} */
   $match: string;
@@ -822,6 +887,7 @@ interface Hooks {
   /** customize name of route (operationId), you can do it with using onCreateRouteName too */
   onFormatRouteName?: (routeInfo: RawRouteInfo, templateRouteName: string) => string | undefined;
 }
+type RouteNameRouteInfo = Record<string, unknown>;
 type RouteNameInfo = {
   usage: string;
   original: string;
@@ -864,6 +930,12 @@ interface ParsedSchema<C> {
   isExtractedResponseBody?: boolean;
   isExtractedResponseError?: boolean;
 }
+interface PathArgInfo {
+  name: string;
+  optional: boolean;
+  type: string;
+  description?: string;
+}
 interface SchemaComponent {
   $ref: string;
   typeName: string;
@@ -1012,18 +1084,45 @@ type ExtractingOptions = {
 };
 interface GenerateApiConfiguration {
   apiConfig: {
+    /** base url from schema */
     baseUrl: string;
+    /** document title */
     title: string;
+    /** document version */
     version: string;
+    /** description split into lines */
     description: string[];
+    /** flag that description is present */
     hasDescription: boolean;
   };
   config: {
+    /** path to swagger schema */
     input: string;
+    /**
+     * generate separated files for http client, data contracts, and routes
+     * @default false
+     */
+    modular: boolean;
+    /**
+     * path to folder where the created api module will be placed.
+     * may be set to `false` to skip writing content to disk; in this case
+     * the `files` array on the return value will contain the generated contents.
+     */
     output: string | false;
+    /** url to swagger schema */
     url: string;
+    /** swagger schema JSON */
     spec: unknown;
+    /**
+     * file name for the generated API module
+     * @default 'Api.ts'
+     */
     fileName: string;
+    /**
+     * path to folder containing custom templates
+     * @default ""
+     */
+    templates: string;
     templatePaths: {
       /** `templates/base` */
       base: string;
@@ -1036,66 +1135,176 @@ interface GenerateApiConfiguration {
       /** custom path to templates (`--templates`) */
       custom: string | null;
     };
+    /** authorisation token for private swagger schema access */
     authorizationToken?: string;
+    /** generate additional information about request responses and error typings */
     generateResponses: boolean;
+    /**
+     * use "default" response status code as success response.
+     * some swagger schemas treat "default" as a successful response.
+     */
     defaultResponseAsSuccess: boolean;
+    /** generate type definitions for API routes */
     generateRouteTypes: boolean;
+    /** generate an API client */
     generateClient: boolean;
+    /** generate all "enum" types as union types (T1 | T2 | TN) */
     generateUnionEnums: boolean;
+    /** parsed swagger schema */
     swaggerSchema: object;
+    /** original swagger schema */
     originalSchema: object;
+    /** map of schema component references */
     componentsMap: Record<string, SchemaComponent>;
+    /** flag indicating the schema was converted from Swagger 2.0 */
     convertedFromSwagger2: boolean;
+    /** determines which path index should be used for routes separation */
     moduleNameIndex: number;
+    /** use the first tag for the module name */
     moduleNameFirstTag: boolean;
+    /** extra templates */
     extraTemplates: {
       name: string;
       path: string;
     }[];
+    /** extract request params to data contract */
     extractRequestParams: boolean;
+    /** unwrap the data item from the response */
     unwrapResponseData: boolean;
+    /** sort data contracts in alphabetical order */
     sortTypes: boolean;
+    /** sort routes in alphabetical order */
     sortRoutes: boolean;
+    /** ability to send HttpClient instance to Api constructor */
     singleHttpClient: boolean;
+    /** prefix string value for type names */
     typePrefix: string;
+    /** suffix string value for type names */
     typeSuffix: string;
+    /** prefix string value for enum keys */
     enumKeyPrefix: string;
+    /** suffix string value for enum keys */
     enumKeySuffix: string;
+    /** fix up small errors in the swagger source definition */
     patch: boolean;
+    /** remove output directory before generating */
     cleanOutput: boolean;
+    /** output debug messages */
     debug: boolean;
+    /**
+     * generate array types as Array<Type>
+     * @default false
+     */
     anotherArrayType: boolean;
+    /** extract request body type to data contract */
     extractRequestBody: boolean;
+    /** generated http client type */
     httpClientType: "axios" | "fetch";
+    /** generate readonly properties */
     addReadonly: boolean;
+    /** customise primitive type mappings */
+    primitiveTypeConstructs?: (struct: PrimitiveTypeStruct) => Partial<PrimitiveTypeStruct>;
+    /** customise code generation constructs */
+    codeGenConstructs?: (struct: CodeGenConstruct) => Partial<CodeGenConstruct>;
+    /** extract response body type to data contract */
     extractResponseBody: boolean;
+    /** extract response error type to data contract */
     extractResponseError: boolean;
+    /** extract all enums from nested types/interfaces to `enum` construction */
     extractEnums: boolean;
+    /** extract all enums from inline interface/type content to typescript enum construction */
     extractResponses: 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;
+    /**
+     * default type for empty response schema
+     * @default "void"
+     */
     defaultResponseType: string;
+    /**
+     * generate js api module with declaration file
+     * @default false
+     */
     toJS: boolean;
+    /** disable throwing on a non-successful response */
     disableThrowOnError: boolean;
+    /**
+     * output only errors to console
+     * @default false
+     */
     silent: boolean;
+    /** hooks for customising the generation process */
     hooks: Partial<Hooks>;
+    /** use enum names as values */
     enumNamesAsValues: boolean;
+    /** package version */
     version: string;
+    /** ts compiler configuration object (for --to-js option) */
     compilerTsConfig: Record<string, unknown>;
+    /** enum key resolver name */
     enumKeyResolverName: string;
+    /** type name resolver name */
     typeNameResolverName: string;
+    /** specific argument name resolver name */
     specificArgNameResolverName: string;
+    /**
+     * custom ts->* translator
+     * do not use constructor args, just send class reference
+     */
     customTranslator?: new () => Translator;
+    /** internal constants */
+    constants: typeof constants_d_exports;
+    /** code generation constructs for TypeScript */
+    Ts: CodeGenConstruct;
+    /**
+     * swagger schema type -> typescript type
+     * https://json-schema.org/understanding-json-schema/reference/string.html#dates-and-times
+     */
+    primitiveTypes: PrimitiveTypeStruct;
+    /** built-in template info */
+    templateInfos: {
+      name: string;
+      fileName: string;
+    }[];
+    /** supported template file extensions */
+    templateExtensions: string[];
+    /** range of HTTP status codes treated as success */
+    successResponseStatusRange: [number, number];
+    /** custom schema parsers */
+    schemaParsers?: {
+      complexOneOf?: MonoSchemaParser;
+      complexAllOf?: MonoSchemaParser;
+      complexAnyOf?: MonoSchemaParser;
+      complexNot?: MonoSchemaParser;
+      enum?: MonoSchemaParser;
+      object?: MonoSchemaParser;
+      complex?: MonoSchemaParser;
+      primitive?: MonoSchemaParser;
+      discriminator?: MonoSchemaParser;
+      array?: MonoSchemaParser;
+    };
+    /** internal options for templates */
     internalTemplateOptions: {
       addUtilRequiredKeysType: boolean;
     };
+    /** resolver for component type names */
     componentTypeNameResolver: ComponentTypeNameResolver;
+    /** generated file names */
     fileNames: {
       dataContracts: string;
       routeTypes: string;
       httpClient: string;
       outOfModuleApi: string;
     };
+    /** Record<templateName, templateContent> */
     templatesToRender: {
       api: string;
       dataContracts: string;
@@ -1108,10 +1317,16 @@ interface GenerateApiConfiguration {
       enumDataContract: string;
       objectFieldJsDoc: string;
     };
+    /** map of duplicate route names */
     routeNameDuplicatesMap: Map<string, string>;
+    /** name of the main exported class */
     apiClassName: string;
-    requestOptions?: RequestInit;
-    extractingOptions: ExtractingOptions;
+    /** configuration for fetching swagger schema requests */
+    requestOptions?: Partial<RequestInit>;
+    /** extra configuration for extracting type names operations */
+    extractingOptions: Partial<ExtractingOptions>;
+    /** update configuration object during generation */
+    update: (update: Partial<GenerateApiConfiguration["config"]>) => void;
   };
   modelTypes: ModelType[];
   hasFormDataRoutes: boolean;
@@ -1142,7 +1357,7 @@ interface GenerateApiConfiguration {
     fmtToJSDocLine: (line: string, params?: {
       eol?: boolean;
     }) => string;
-    _: lodash0$1.LoDashStatic;
+    _: lodash0.LoDashStatic;
     require: (path: string) => unknown;
   };
 }
@@ -1586,7 +1801,7 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
       }) => string;
       NameResolver: typeof NameResolver;
       _: lodash0.LoDashStatic;
-      require: (packageOrPath: string) => Promise<any>;
+      require: (packageOrPath: string) => any;
     };
   };
   getTemplate: (name: string, fileName: string, path?: string) => string | undefined;
@@ -1611,5 +1826,5 @@ declare function generateApi(config: Partial<GenerateApiConfiguration["config"]>
   }) => Promise<string>;
 }>;
 //#endregion
-export { constants_d_exports as constants, generateApi, generateTemplates };
+export { ExtractingOptions, GenerateApiConfiguration, GenerateApiOutput, GenerateApiParams, GenerateTemplatesOutput, GenerateTemplatesParams, Hooks, HttpClientType, ModelType, ParsedRoute, ParsedRouteRequest, ParsedRouteResponse, ParsedSchema, PathArgInfo, RawRouteInfo, RequestContentKind, RequestResponseInfo, RouteNameInfo, RouteNameRouteInfo, SCHEMA_TYPES, SchemaComponent, SchemaTypeEnumContent, SchemaTypeObjectContent, SchemaTypePrimitiveContent, constants_d_exports as constants, generateApi, generateTemplates };
 //# sourceMappingURL=lib.d.ts.map

package/dist/lib.js

@@ -1,3 +1,3 @@
-import { constants_exports, generateApi, generateTemplates } from "./src-4gUT3jPg.js";
+import { RequestContentKind, SCHEMA_TYPES, constants_exports, generateApi, generateTemplates } from "./src-s8addnrG.js";
 
-export { constants_exports as constants, generateApi, generateTemplates };
+export { RequestContentKind, SCHEMA_TYPES, constants_exports as constants, generateApi, generateTemplates };