@moccona/apicodegen 0.0.3 → 0.0.7

package/npm/index.d.ts

@@ -1,536 +0,0 @@
-import * as typescript from 'typescript';
-import { Statement, Node, ParameterDeclaration, TypeNode, Block } from 'typescript';
-import { OpenAPIV3 } from 'openapi-types';
-import { ServerOptions, PluginOption } from 'vite';
-
-/**
- * Simple represenration for JSON object
- */
-type JSONValue = {
-    [K: string]: string | number | boolean | JSONValue | (string | number | boolean | JSONValue)[];
-};
-declare enum SchemaType {
-    schemas = "schemas",
-    parameters = "parameters",
-    responses = "responses",
-    requestBodies = "requestBodies"
-}
-declare enum NonArraySchemaType {
-    "object" = "object",
-    "string" = "string",
-    "number" = "number",
-    "boolean" = "boolean",
-    "integer" = "integer",
-    "enum" = "enum",
-    "file" = "file"
-}
-declare enum ArraySchemaType {
-    "array" = "array"
-}
-declare enum SchemaFormatType {
-    "string" = "string",
-    "number" = "number",
-    "boolean" = "boolean",
-    "file" = "file",
-    "binary" = "binary",
-    "blob" = "blob"
-}
-declare enum ParameterIn {
-    "header" = "header",
-    "body" = "body",
-    "query" = "query",
-    "cookie" = "cookie",
-    "path" = "path",
-    "formData" = "formData"
-}
-interface ReferenceObject {
-    $ref: string;
-}
-interface EnumSchemaObject {
-    name: string;
-    enum: (string | number)[];
-}
-interface SingleTypeSchemaObject {
-    type: keyof typeof NonArraySchemaType | string;
-    description?: string;
-    allOf?: SchemaObject[];
-    anyOf?: SchemaObject[];
-    deprecated?: boolean;
-    enum?: (string | number)[];
-    format?: keyof typeof SchemaFormatType;
-    oneOf?: SchemaObject[];
-    properties?: Record<string, SchemaObject>;
-    readonly?: boolean;
-    required?: string[] | boolean;
-    ref?: string;
-}
-interface ArrayTypeSchemaObject {
-    type: keyof typeof ArraySchemaType;
-    items?: SchemaObject;
-    required?: boolean;
-    description?: string;
-    ref?: string;
-}
-type SchemaObject = SingleTypeSchemaObject | ArrayTypeSchemaObject;
-type ParameterObject = {
-    name: string;
-    in: keyof typeof ParameterIn;
-    schema?: SchemaObject;
-    required?: boolean;
-    description?: string;
-    deprecated?: boolean;
-    ref?: string;
-};
-declare enum MediaTypes {
-    JSON = "application/json",
-    TEXT = "text",
-    IMAGE = "image",
-    AUDIO = "audio",
-    VIDEO = "video"
-}
-type MediaTypeObject = {
-    type: MediaTypes | keyof typeof MediaTypes;
-    schema?: SchemaObject;
-};
-type ResponsesObject = Record<string, MediaTypeObject[]>;
-type RequestBodyObject = ResponsesObject;
-declare enum HttpMethods {
-    GET = "get",
-    PUT = "put",
-    POST = "post",
-    DELETE = "delete",
-    OPTIONS = "options",
-    HEAD = "head",
-    PATCH = "patch",
-    TRACE = "trace"
-}
-type OperationObject = {
-    method: string;
-    summary?: string;
-    description?: string;
-    operationId?: string;
-    externalDocs?: {
-        url: string;
-        description?: string;
-    }[];
-    parameters?: ParameterObject[];
-    requestBody?: MediaTypeObject[];
-    responses: MediaTypeObject[];
-    deprecated?: boolean;
-};
-type PathObject = {
-    ref?: string;
-    summary?: string;
-    description?: string;
-    parameters?: ParameterObject[];
-} & Partial<Record<HttpMethods, OperationObject>>;
-type PathsObject = Record<string, OperationObject[]>;
-type FetchDocRequestInit = {
-    method?: string;
-    body?: string | FormData;
-    headers?: Record<string, string>;
-};
-declare enum Adaptors {
-    fetch = "fetch",
-    axios = "axios"
-}
-type ProviderInitOptions = {
-    docURL: string;
-    output: string;
-    baseURL?: string;
-    importClientSource?: string;
-    requestOptions?: FetchDocRequestInit;
-    verbose?: boolean;
-    adaptor?: keyof typeof Adaptors;
-};
-interface ProviderInitResult {
-    readonly enums: EnumSchemaObject[];
-    readonly schemas: Record<string, SchemaObject>;
-    readonly parameters: Record<string, ParameterObject>;
-    readonly responses: Record<string, ResponsesObject>;
-    readonly requestBodies: Record<string, RequestBodyObject>;
-    readonly apis: PathsObject;
-}
-
-/**
- * @file Adapter abstract class definition
- * @author wp.l
- * @description Base adapter implementation for various code generation tools
- */
-
-/**
- * Base adapter for tool
- * This abstract class serves as the foundation for implementing adapters for different code generation tools
- */
-declare abstract class Adapter {
-    /**
-     * @abstract The unique name/identifier for this adapter implementation
-     */
-    abstract readonly name: string;
-    /**
-     * @abstract The name of the field used to specify the HTTP method in API calls
-     */
-    abstract readonly methodFieldName: string;
-    /**
-     * @abstract The name of the field used to specify the request body in API calls
-     */
-    abstract readonly bodyFieldName: string;
-    /**
-     * @abstract The name of the field used to specify request headers in API calls
-     */
-    abstract readonly headersFieldName: string;
-    /**
-     * @abstract The name of the field used to specify query parameters in API calls
-     */
-    abstract readonly queryFieldName: string;
-    /**
-     * @abstract
-     * @param {string} uri - The API endpoint URI
-     * @param {string} method - The HTTP method (e.g., GET, POST, etc.)
-     * @param {ParameterObject[]} parameters - An array of parameters for the API call
-     * @param {MediaTypeObject | undefined} requestBody - The request body payload (if applicable)
-     * @param {MediaTypeObject | undefined} response - The expected response format (if applicable)
-     * @param {Adapter} adapter - An instance of the adapter being used
-     * @param {boolean} useFormData - Flag indicating whether to use FormData for the request body
-     * @param {boolean} useJSONResponse - Flag indicating whether the response should be parsed as JSON
-     * @returns {Statement[]} An array of TypeScript AST statements representing the generated code
-     */
-    abstract client(uri: string, method: string, parameters: ParameterObject[], requestBody: MediaTypeObject | undefined, response: MediaTypeObject | undefined, adapter: Adapter, useFormData: boolean, useJSONResponse: boolean): Statement[];
-}
-
-/**
- * @file Base class implementation
- * @author wp.l
- * @description Base utility class providing common methods for code generation and API handling
- */
-
-/**
- * Represents success HTTP status codes.
- * Each key is a string representation of a success HTTP status code.
- */
-declare const SuccessHttpStatusCode: {
-    "200": string;
-    "201": string;
-    "202": string;
-    "203": string;
-    "204": string;
-    "205": string;
-    "206": string;
-    "207": string;
-    "208": string;
-    "226": string;
-};
-/**
- * Base abstract class providing common utility methods.
- */
-declare abstract class Base {
-    protected constructor();
-    /**
-     * Converts a reference string to a meaningful name.
-     * @param ref - The reference string to process.
-     * @param [doc] - Optional document reference for context.
-     * @returns - The processed name.
-     */
-    static ref2name(ref: string, doc?: any): string;
-    /**
-     * Converts an API path to a function name.
-     * @param path - The API endpoint path.
-     * @param [method] - The HTTP method (e.g., GET, POST).
-     * @param [operationId] - Unique identifier for the operation.
-     * @returns - The generated function name.
-     */
-    static pathToFnName(path: string, method?: string, _operationId?: string): string;
-    /**
-     * Normalizes a string by replacing special characters and avoiding TypeScript keywords.
-     * @param text - Input text to normalize.
-     * @returns - The normalized string.
-     */
-    static normalize(text: string): string;
-    /**
-     * Capitalizes the first character of a string.
-     * @param text - Input string.
-     * @returns - Capitalized string.
-     */
-    static capitalize(text: string): string;
-    /**
-     * Converts a string to camelCase.
-     * @param text - Input string.
-     * @returns - CamelCase string.
-     */
-    static camelCase(text: string): string;
-    /**
-     * Converts a string to UpperCamelCase.
-     * @param text - Input string.
-     * @returns - UpperCamelCase string.
-     */
-    static upperCamelCase(text: string): string;
-    /**
-     * Fetches documentation from a given URL.
-     * @param url - The URL to fetch the documentation from.
-     * @param requestInit - Additional request parameters.
-     * @returns - A promise resolving to the fetched documentation data.
-     */
-    static fetchDoc<T = unknown>(url: string, requestInit?: FetchDocRequestInit): Promise<T>;
-    /**
-     * Determines the media type from a given media type string.
-     * @param mediaType - The media type string to evaluate.
-     * @returns - The matched MediaTypes or null.
-     */
-    static getMediaType(mediaType: string): MediaTypes | undefined;
-    /**
-     * Checks if a schema is a valid enum type that isn't boolean.
-     * @param a - The schema object to evaluate.
-     * @returns - True if the schema is a valid non-boolean enum.
-     */
-    static isValidEnumType(a: SchemaObject): boolean;
-    /**
-     * Checks if a schema represents a boolean enum.
-     * @param a - The schema object to evaluate.
-     * @returns - True if the schema is a boolean enum.
-     */
-    static isBooleanEnum(a: SchemaObject): boolean;
-    /**
-     * Checks if two enum schemas are identical.
-     * @param a - First enum schema to compare.
-     * @param b - Second enum schema to compare.
-     * @returns - True if the enums are identical.
-     */
-    private static isSameEnum;
-    /**
-     * Filters out duplicate enum schemas from an array.
-     * @param enums - Array of enum schemas to process.
-     * @returns - Array of unique enum schemas.
-     */
-    static uniqueEnums(enums: EnumSchemaObject[]): EnumSchemaObject[];
-    /**
-     * Finds the first occurrence of a matching enum schema in an array.
-     * @param a - The enum schema to find.
-     * @param enums - Array of enum schemas to search.
-     * @returns - The found schema or undefined.
-     */
-    static findSameSchema(a: EnumSchemaObject, enums: EnumSchemaObject[]): EnumSchemaObject | undefined;
-    /**
-     * Checks if an object is a reference object.
-     * @param schema - The object to check.
-     * @returns - True if the object is a reference.
-     */
-    static isRef(schema: unknown): schema is ReferenceObject;
-}
-
-/**
- * @file Base class implementation
- * @author wp.l
- * @description This file defines the `Provider` abstract class, which serves as a base for providers responsible for parsing and processing API documentation.
- */
-
-/**
- * Abstract Provider Class.
- *
- * The Provider class is designed to be extended by specific implementations (e.g., OpenAPI 2 provider, OpenAPI 3 provider).
- * It handles the initialization of the provider and the parsing of documentation into structured data.
- *
- * @example
- *
- * ```ts
- * /// Example of how this class might be used by a subclass:
- * class OpenAPIProvider extends Provider {
- *   /// Implement the parse method to handle OpenAPI-specific documentation parsing.
- *   parse(doc: unknown): ProviderInitResult {
- *     /// Implementation details...
- *   }
- * }
- *
- * /// Initializing a provider with configuration and documentation data:
- * const initOptions: ProviderInitOptions = {
- *   docURL: "https://example.com/api/swagger.json",
- *   baseURL: "https://api.example.com",
- *   output: "./generated",
- *   requestOptions: {
- *     headers: { "Content-Type": "application/json" },
- *   },
- *   importClientSource: "generated/client",
- * };
- *
- * const docData = fetchSwaggerDoc();
- * const provider = new OpenAPIProvider(initOptions, docData);
- * ```
- */
-declare abstract class Provider implements ProviderInitResult, ProviderInitOptions {
-    /** collection of enum schemas */
-    readonly enums: EnumSchemaObject[];
-    /** collection of schemas indexed by name */
-    readonly schemas: Record<string, SchemaObject>;
-    /** collection of parameters indexed by name */
-    readonly parameters: Record<string, ParameterObject>;
-    /** collection of API responses indexed by name */
-    readonly responses: Record<string, ResponsesObject>;
-    /** collection of request bodies indexed by name */
-    readonly requestBodies: Record<string, RequestBodyObject>;
-    /** collection of API endpoints (operations) indexed by path */
-    readonly apis: Record<string, OperationObject[]>;
-    /** URL for fetching API documentation */
-    readonly docURL: string;
-    /** base URL for API endpoints */
-    readonly baseURL: string;
-    /** output directory for generated code */
-    readonly output: string;
-    /** request options for API documentation fetch */
-    readonly requestOptions: FetchDocRequestInit;
-    /** source path for imported client */
-    readonly importClientSource: string;
-    /**
-     * Provider Constructor.
-     * @param {ProviderInitOptions} initOptions - Initial configuration for the provider.
-     * @param {unknown} doc - Raw API documentation data to be parsed.
-     */
-    constructor(initOptions: ProviderInitOptions, doc: unknown);
-    /**
-     * Abstract Parse Method.
-     * @abstract
-     * @param {unknown} doc - Raw API documentation data.
-     * @returns {ProviderInitResult} - Parsed documentation data.
-     *
-     * This method must be implemented by subclasses to parse the raw documentation into structured data.
-     */
-    abstract parse(doc: unknown): ProviderInitResult;
-}
-
-/**
- * File containing the implementation of the AxiosAdapter class.
- * This adapter is responsible for generating code that uses the Axios HTTP client library.
- */
-
-/**
- * Adapter class implementing support for generating code that makes use of the Axios HTTP client library.
- * This class defines custom behavior and field mappings specific to the Axios client.
- */
-declare class AxiosAdapter extends Adapter {
-    /**
-     * Name of the field used to specify the HTTP method in the request configuration.
-     */
-    readonly methodFieldName = "method";
-    /**
-     * Name of the field used to specify the request body (data) in the request configuration.
-     */
-    readonly bodyFieldName = "data";
-    /**
-     * Name of the field used to specify the request headers in the request configuration.
-     */
-    readonly headersFieldName = "headers";
-    /**
-     * Name of the field used to specify the query parameters in the request configuration.
-     */
-    readonly queryFieldName = "params";
-    /**
-     * The name of the client this adapter is configured for, which is 'axios' in this case.
-     */
-    readonly name = "axios";
-    /**
-     * Method that should generate and return the client-specific configuration statements.
-     *
-     * @returns {Statement[]} An array of TypeScript statements that define the client configuration.
-     *
-     * @throws {Error} Indicates that the method is not yet implemented and needs to be filled in.
-     */
-    client(uri: string, method: string, parameters: ParameterObject[], requestBody: MediaTypeObject | undefined, response: MediaTypeObject | undefined, adapter: Adapter, shouldUseFormData: boolean): Statement[];
-}
-
-/**
- * FetchAdapter is an adapter class that generates client-side fetch requests.
- * It handles parameters, headers, and request bodies to construct proper fetch calls.
- */
-declare class FetchAdapter extends Adapter {
-    readonly methodFieldName = "method";
-    readonly bodyFieldName = "body";
-    readonly headersFieldName = "headers";
-    readonly queryFieldName = "";
-    readonly name = "fetch";
-    /**
-     * Generates client code for making API requests using the Fetch API.
-     * @param uri - The API endpoint URI
-     * @param method - The HTTP method (GET, POST, etc.)
-     * @param parameters - Array of parameters to include in the request
-     * @param requestBody - The request body media type definition
-     * @param response - The response media type definition
-     * @param adapter - The adapter instance
-     * @param shouldUseFormData - Flag to use FormData for the request body
-     * @param shouldUseJSONResponse - Flag to use JSON parsing for the response
-     * @return - An array of generated TypeScript statements
-     */
-    client(uri: string, method: string, parameters: ParameterObject[], requestBody: MediaTypeObject | undefined, response: MediaTypeObject | undefined, adapter: Adapter, shouldUseFormData: boolean, shouldUseJSONResponse: boolean): Statement[];
-}
-
-/**
- * Represents a comment object with optional tag and message.
- */
-type CommentObject = {
-    tag?: string;
-    comment: string;
-};
-/**
- * Array of comment objects to be added to the code.
- */
-type Comments = CommentObject[];
-declare class Generator {
-    /**
-     * Converts an array of TypeScript statements into a formatted string of code.
-     *
-     * @param statements - The array of TypeScript statement nodes.
-     * @returns Formatted code as a string.
-     * @throws {Error} If no valid statements are provided.
-     */
-    static toCode(statements: Statement[]): string;
-    static write(code: string, filepath: string): Promise<void>;
-    /**
-     * Converts a path string with parameters into a TypeScript template expression.
-     * Handles query parameters and path placeholders.
-     *
-     * @param path - The base path string containing placeholders.
-     * @param parameters - Array of parameter objects defining the parameters.
-     * @param basePath - Optional base path to prepend (default: "").
-     * @returns A TypeScript template expressi
-     */
-    static toUrlTemplate(path: string, parameters: ParameterObject[], basePath?: string): typescript.NoSubstitutionTemplateLiteral | typescript.TemplateExpression;
-    /**
-     * Adds synthetic comments to a TypeScript AST node.
-     *
-     * @param node - The target AST node.
-     * @param comments - Array of comment objects to add.
-     */
-    static addComments(node: Node, comments: Comments): void;
-    /**
-     * Checks if a schema represents a binary type.
-     *
-     * @param schema - The schema object to check.
-     * @returns true if the schema is a binary type, false otherwise.
-     */
-    static isBinarySchema(schema: SchemaObject): boolean;
-    static toRequestBodyTypeNode(schema: SchemaObject): ParameterDeclaration;
-    static toTypeNode(schema: SchemaObject): TypeNode;
-    static toDeclarationNodes(parameters: ParameterObject[]): ParameterDeclaration[];
-    static toFormDataStatement(parameters: ParameterObject[], requestBody?: SchemaObject): Statement[];
-    static bodyBlock(uri: string, method: string, parameters: ParameterObject[], requestBody: MediaTypeObject | undefined, response: MediaTypeObject | undefined, adapter: Adapter): Block;
-    static schemaToStatemets(parsedDoc: ProviderInitResult, adaptor: Adapter, options: Omit<ProviderInitOptions, "docURL" | "output" | "requestOptions">): Statement[];
-    static prettier(code: string): Promise<string>;
-    static genCode(schema: ProviderInitResult, initOptions: ProviderInitOptions, adaptor: Adapter): Promise<string>;
-}
-
-declare enum OpenAPIVersion {
-    v2 = "v2",
-    v3 = "v3",
-    v3_1 = "v3_1",
-    unknown = "unknown"
-}
-declare class OpenAPIProvider extends Provider {
-    parse(doc: OpenAPIV3.Document): ProviderInitResult;
-}
-declare function codeGen(initOptions: ProviderInitOptions): Promise<string>;
-
-type apiCodeGenPluginOptions = ProviderInitOptions & {
-    name: string;
-    proxy?: ServerOptions["proxy"];
-};
-declare const tsc: (path: string) => Promise<void>;
-declare function apiCodeGenPlugin(options: apiCodeGenPluginOptions[]): PluginOption;
-
-export { Adapter, Adaptors, ArraySchemaType, type ArrayTypeSchemaObject, AxiosAdapter, Base, type CommentObject, type Comments, type EnumSchemaObject, FetchAdapter, type FetchDocRequestInit, Generator, HttpMethods, type JSONValue, type MediaTypeObject, MediaTypes, NonArraySchemaType, OpenAPIProvider, OpenAPIVersion, type OperationObject, ParameterIn, type ParameterObject, type PathObject, type PathsObject, Provider, type ProviderInitOptions, type ProviderInitResult, type ReferenceObject, type RequestBodyObject, type ResponsesObject, SchemaFormatType, type SchemaObject, SchemaType, type SingleTypeSchemaObject, SuccessHttpStatusCode, apiCodeGenPlugin, type apiCodeGenPluginOptions, codeGen, tsc };