genoc 0.1.0

package/dist/parser/version/version-strategy.d.ts

@@ -0,0 +1,31 @@
+import type { ValidationResult } from '../validators.js';
+import type { NormalizedSpec } from './normalized-spec.js';
+/**
+ * Version strategy interface for multi-version OpenAPI support
+ */
+export interface VersionStrategy {
+    /**
+     * Get the supported OpenAPI version
+     */
+    version(): string;
+    /**
+     * Check if this strategy matches the given OpenAPI specification
+     */
+    matches(spec: unknown): boolean;
+    /**
+     * Normalize a raw OpenAPI specification to a consistent format
+     */
+    normalizeSpec(rawSpec: unknown): NormalizedSpec;
+    /**
+     * Validate the normalized specification
+     */
+    validateSpec(spec: NormalizedSpec): ValidationResult;
+    /**
+     * Resolve a reference within the document context
+     */
+    resolveRef(ref: string, doc: unknown, context?: unknown): unknown;
+    /**
+     * Get supported features for this version
+     */
+    getSupportedFeatures(): string[];
+}

package/dist/parser/version/version-strategy.js

@@ -0,0 +1 @@
+export {};

package/dist/types/client.d.ts

@@ -0,0 +1,25 @@
+export type MethodNameStrategy = 'path-based' | 'operationId' | 'operationId-with-fallback';
+export type GeneratorConfig = {
+    input: string;
+    outputDir: string;
+    methodNameStrategy?: MethodNameStrategy;
+    requesterModuleName?: string;
+    specVersion?: string;
+    strictVersion?: boolean;
+};
+export type RequesterFunction = <TResponse>(method: string, path: string, options: {
+    query?: Record<string, unknown>;
+    body?: unknown;
+    headers?: Record<string, string>;
+}) => Promise<TResponse>;
+export type GeneratedMethod = {
+    name: string;
+    jsDoc: string;
+    signature: string;
+    implementation: string;
+};
+export type ClientOutput = {
+    imports: string[];
+    methods: GeneratedMethod[];
+    errorTypes: string[];
+};

package/dist/types/client.js

@@ -0,0 +1 @@
+export {};

package/dist/types/contracts.d.ts

@@ -0,0 +1,13 @@
+export type TypeMappingResult = {
+    tsType: string;
+    imports: string[];
+};
+export type ContractEntry = {
+    name: string;
+    kind: 'interface' | 'type' | 'enum';
+    definition: string;
+    jsDoc?: string;
+};
+export type ContractsOutput = {
+    entries: ContractEntry[];
+};

package/dist/types/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/types/openapi.d.ts

@@ -0,0 +1,173 @@
+export type ReferenceObject = {
+    $ref: string;
+};
+export type SchemaObject = {
+    type?: string | string[];
+    format?: string;
+    properties?: Record<string, SchemaObject>;
+    required?: string[];
+    items?: SchemaObject;
+    additionalProperties?: boolean | SchemaObject;
+    $ref?: string;
+    allOf?: SchemaObject[];
+    oneOf?: SchemaObject[];
+    anyOf?: SchemaObject[];
+    enum?: unknown[];
+    const?: unknown;
+    default?: unknown;
+    description?: string;
+    nullable?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+    discriminator?: {
+        propertyName: string;
+        mapping?: Record<string, string>;
+    };
+};
+export type MediaTypeObject = {
+    schema?: SchemaObject | ReferenceObject;
+    examples?: Record<string, unknown>;
+    example?: unknown;
+    encoding?: Record<string, unknown>;
+};
+export type ParameterObject = {
+    name: string;
+    in: 'query' | 'path' | 'header' | 'cookie';
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    schema?: SchemaObject | ReferenceObject;
+    style?: string;
+    explode?: boolean;
+    allowEmptyValue?: boolean;
+    example?: unknown;
+    examples?: Record<string, unknown>;
+};
+export type RequestBodyObject = {
+    description?: string;
+    content: Record<string, MediaTypeObject>;
+    required?: boolean;
+};
+export type ResponseObject = {
+    description: string;
+    headers?: Record<string, unknown>;
+    content?: Record<string, MediaTypeObject>;
+    links?: Record<string, unknown>;
+};
+export type ResponsesObject = Record<string, ResponseObject | ReferenceObject>;
+export type OperationObject = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses: ResponsesObject;
+    deprecated?: boolean;
+    security?: unknown[];
+    servers?: unknown[];
+};
+export type PathItemObject = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    servers?: unknown[];
+};
+export type PathsObject = Record<string, PathItemObject>;
+export type ServerVariableObject = {
+    default: string;
+    description?: string;
+    enum?: string[];
+};
+export type ServerObject = {
+    url: string;
+    description?: string;
+    variables?: Record<string, ServerVariableObject>;
+};
+export type InfoObject = {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: {
+        name?: string;
+        url?: string;
+        email?: string;
+    };
+    license?: {
+        name: string;
+        url?: string;
+        identifier?: string;
+    };
+};
+export type OAuth2FlowBase = {
+    refreshUrl?: string;
+    scopes: Record<string, string>;
+};
+export type OAuth2FlowImplicit = OAuth2FlowBase & {
+    authorizationUrl: string;
+};
+export type OAuth2FlowPassword = OAuth2FlowBase & {
+    tokenUrl: string;
+};
+export type OAuth2FlowClientCredentials = OAuth2FlowBase & {
+    tokenUrl: string;
+};
+export type OAuth2FlowAuthorizationCode = OAuth2FlowBase & {
+    authorizationUrl: string;
+    tokenUrl: string;
+};
+export type OAuth2FlowsObject = {
+    implicit?: OAuth2FlowImplicit;
+    password?: OAuth2FlowPassword;
+    clientCredentials?: OAuth2FlowClientCredentials;
+    authorizationCode?: OAuth2FlowAuthorizationCode;
+};
+export type SecuritySchemeObject = {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuth2FlowsObject;
+    openIdConnectUrl?: string;
+};
+export type ComponentsObject = {
+    schemas?: Record<string, SchemaObject | ReferenceObject>;
+    responses?: Record<string, ResponseObject | ReferenceObject>;
+    parameters?: Record<string, ParameterObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+    headers?: Record<string, unknown>;
+    securitySchemes?: Record<string, SecuritySchemeObject>;
+    links?: Record<string, unknown>;
+    callbacks?: Record<string, unknown>;
+    examples?: Record<string, unknown>;
+};
+export type OpenAPIDocument = {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths?: PathsObject;
+    components?: ComponentsObject;
+    security?: unknown[];
+    tags?: unknown[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+    webhooks?: Record<string, PathItemObject>;
+};

package/dist/types/openapi.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/case.d.ts

@@ -0,0 +1,5 @@
+export declare function kebabToPascalCase(str: string): string;
+export declare function camelCase(str: string): string;
+export declare function pascalCase(str: string): string;
+export declare function toPascalCaseSegment(segment: string): string;
+export declare function formatToBrandTypeName(format: string, openApiType: string): string;

package/dist/utils/case.js

@@ -0,0 +1,51 @@
+export function kebabToPascalCase(str) {
+    if (!str)
+        return '';
+    return str
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+export function camelCase(str) {
+    if (!str)
+        return '';
+    return str.charAt(0).toLowerCase() + str.slice(1).toLowerCase();
+}
+export function pascalCase(str) {
+    if (!str)
+        return '';
+    return str
+        .split(/[\s-_]+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+export function toPascalCaseSegment(segment) {
+    if (!segment)
+        return '';
+    if (/^[A-Z]/.test(segment) && /^[A-Za-z0-9]+$/.test(segment)) {
+        return segment;
+    }
+    if (segment.includes('-')) {
+        return kebabToPascalCase(segment);
+    }
+    return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+export function formatToBrandTypeName(format, openApiType) {
+    const formatName = pascalCase(format);
+    let baseType;
+    switch (openApiType) {
+        case 'string':
+            baseType = 'String';
+            break;
+        case 'number':
+        case 'integer':
+            baseType = 'Number';
+            break;
+        case 'boolean':
+            baseType = 'Boolean';
+            break;
+        default:
+            baseType = openApiType.charAt(0).toUpperCase() + openApiType.slice(1);
+    }
+    return formatName + baseType;
+}

package/dist/utils/generator-helpers.d.ts

@@ -0,0 +1,23 @@
+import type { AnalyzedOperation } from '../analyzer/path-analyzer.js';
+/**
+ * Convert a string to PascalCase, handling camelCase, kebab-case, snake_case,
+ * and colon-separated segments.
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Build a PascalCase type-name prefix from an operation's method + path.
+ * get + /api/v1/products → "GetApiV1Products"
+ */
+export declare function getOperationTypePrefix(op: AnalyzedOperation): string;
+/**
+ * Determine the success return type for an operation.
+ */
+export declare function getSuccessType(op: AnalyzedOperation): string;
+/**
+ * Determine the error type name for an operation.
+ */
+export declare function getErrorType(op: AnalyzedOperation): string;
+/**
+ * Generate the auto-generated header comment.
+ */
+export declare function makeHeader(version: string): string;

package/dist/utils/generator-helpers.js

@@ -0,0 +1,66 @@
+/**
+ * Convert a string to PascalCase, handling camelCase, kebab-case, snake_case,
+ * and colon-separated segments.
+ */
+export function toPascalCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[-_\s:]/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+/**
+ * Build a PascalCase type-name prefix from an operation's method + path.
+ * get + /api/v1/products → "GetApiV1Products"
+ */
+export function getOperationTypePrefix(op) {
+    const methodPascal = op.method.charAt(0).toUpperCase() + op.method.slice(1).toLowerCase();
+    const segments = op.path
+        .split('/')
+        .filter((s) => s.length > 0)
+        .map((s) => {
+        const cleaned = s.replace(/[{}]/g, '');
+        return toPascalCase(cleaned);
+    });
+    return methodPascal + segments.join('');
+}
+/**
+ * Determine the success return type for an operation.
+ */
+export function getSuccessType(op) {
+    const successResponses = op.responses.filter((r) => r.isSuccess);
+    if (successResponses.length === 0) {
+        return 'unknown';
+    }
+    const noContent = successResponses.find((r) => r.tsType === 'void');
+    const hasOnlyNoContent = noContent && successResponses.every((r) => r.tsType === 'void');
+    if (hasOnlyNoContent) {
+        return 'void';
+    }
+    const withSchema = successResponses.filter((r) => r.tsType !== 'void');
+    if (withSchema.length === 0) {
+        return 'void';
+    }
+    const prefix = getOperationTypePrefix(op);
+    const types = withSchema.map(() => `${prefix}Response`);
+    const unique = [...new Set(types)];
+    return unique.join(' | ');
+}
+/**
+ * Determine the error type name for an operation.
+ */
+export function getErrorType(op) {
+    const prefix = getOperationTypePrefix(op);
+    const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
+    if (errorResponses.length === 0) {
+        return 'never';
+    }
+    return `${prefix}Errors`;
+}
+/**
+ * Generate the auto-generated header comment.
+ */
+export function makeHeader(version) {
+    return `// Auto-generated by genoc from OpenAPI ${version} spec. DO NOT EDIT.`;
+}

package/dist/utils/string.d.ts

@@ -0,0 +1,34 @@
+/**
+ * String utility functions for OpenAPI client generator
+ */
+/**
+ * Indent each line of a string by the specified level (2 spaces per level)
+ * @param str The string to indent
+ * @param level Number of levels to indent (each level = 2 spaces)
+ * @returns Indented string, or empty string if input is empty
+ */
+export declare function indent(str: string, level: number): string;
+/**
+ * Capitalize the first character of a string
+ * @param str The string to capitalize
+ * @returns String with first character uppercase, rest unchanged
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Check if a string is a JavaScript/TypeScript reserved word
+ * @param str The string to check
+ * @returns True if the string is a reserved word
+ */
+export declare function isReservedWord(str: string): boolean;
+/**
+ * Sanitize a string to make it safe for TypeScript identifier usage
+ * @param str The string to sanitize
+ * @returns Safe TypeScript identifier
+ */
+export declare function sanitizeIdentifier(str: string): string;
+/**
+ * Quote a key if needed for TypeScript object literals
+ * @param key The key to potentially quote
+ * @returns Quoted key if needed, original key otherwise
+ */
+export declare function quoteKey(key: string): string;

package/dist/utils/string.js

@@ -0,0 +1,182 @@
+/**
+ * String utility functions for OpenAPI client generator
+ */
+/**
+ * Indent each line of a string by the specified level (2 spaces per level)
+ * @param str The string to indent
+ * @param level Number of levels to indent (each level = 2 spaces)
+ * @returns Indented string, or empty string if input is empty
+ */
+export function indent(str, level) {
+    if (!str)
+        return '';
+    const prefix = '  '.repeat(Math.max(0, level));
+    return str
+        .split('\n')
+        .map((line) => (line ? `${prefix}${line}` : line)) // preserve empty lines without adding extra indentation
+        .join('\n');
+}
+/**
+ * Capitalize the first character of a string
+ * @param str The string to capitalize
+ * @returns String with first character uppercase, rest unchanged
+ */
+export function capitalize(str) {
+    if (!str)
+        return str;
+    return str[0].toUpperCase() + str.slice(1);
+}
+/**
+ * Check if a string is a JavaScript/TypeScript reserved word
+ * @param str The string to check
+ * @returns True if the string is a reserved word
+ */
+export function isReservedWord(str) {
+    if (!str)
+        return false;
+    const reservedWords = new Set([
+        // Keywords
+        'class',
+        'return',
+        'const',
+        'let',
+        'var',
+        'function',
+        'if',
+        'else',
+        'for',
+        'while',
+        'do',
+        'switch',
+        'case',
+        'break',
+        'continue',
+        'try',
+        'catch',
+        'finally',
+        'throw',
+        'new',
+        'this',
+        'super',
+        'extends',
+        'implements',
+        'interface',
+        'type',
+        'enum',
+        'abstract',
+        'async',
+        'await',
+        'yield',
+        'import',
+        'export',
+        'from',
+        'default',
+        'delete',
+        'in',
+        'instanceof',
+        'typeof',
+        'void',
+        'with',
+        'debugger',
+        // Literals
+        'null',
+        'true',
+        'false',
+        'undefined',
+        'nan',
+        'NaN',
+        'Infinity',
+        // TypeScript specific
+        'of',
+        'as',
+        'keyof',
+        'readonly',
+        'declare',
+        'namespace',
+        'module',
+        'require',
+        'public',
+        'private',
+        'protected',
+        'static',
+        'constructor',
+    ]);
+    return reservedWords.has(str.toLowerCase());
+}
+/**
+ * Sanitize a string to make it safe for TypeScript identifier usage
+ * @param str The string to sanitize
+ * @returns Safe TypeScript identifier
+ */
+export function sanitizeIdentifier(str) {
+    if (!str)
+        return '_';
+    if (/^\d/.test(str)) {
+        return `_${str}`;
+    }
+    if (isReservedWord(str)) {
+        return `_${str}`;
+    }
+    const segments = str
+        .replace(/[^a-zA-Z0-9]/g, ' ')
+        .split(/\s+/)
+        .filter(Boolean);
+    const commonReserved = new Set([
+        'class',
+        'const',
+        'function',
+        'if',
+        'else',
+        'for',
+        'while',
+        'return',
+        'var',
+        'let',
+    ]);
+    if (segments.length > 0 && commonReserved.has(segments[0].toLowerCase())) {
+        const sanitized = str.replace(/[^a-zA-Z0-9]/g, '_');
+        const final = sanitized.replace(/_+/g, '_');
+        return `_${final}`;
+    }
+    const ascii = str.replace(/[üöäÜÖÄ]/g, (match) => {
+        switch (match) {
+            case 'ü':
+                return 'u';
+            case 'ö':
+                return 'o';
+            case 'ä':
+                return 'a';
+            case 'Ü':
+                return 'U';
+            case 'Ö':
+                return 'O';
+            case 'Ä':
+                return 'A';
+            default:
+                return match;
+        }
+    });
+    const sanitized = ascii.replace(/[^a-zA-Z0-9$]/g, '_');
+    const final = sanitized.replace(/_+/g, '_');
+    if (!final || final === '_' || final === '$' || /^[_$]+$/.test(final)) {
+        return '_';
+    }
+    return final;
+}
+/**
+ * Quote a key if needed for TypeScript object literals
+ * @param key The key to potentially quote
+ * @returns Quoted key if needed, original key otherwise
+ */
+export function quoteKey(key) {
+    if (!key)
+        return '""';
+    // Check if the key needs quoting
+    const needsQuoting = isReservedWord(key) ||
+        /[^a-zA-Z0-9_$]/.test(key) ||
+        key.startsWith(' ') ||
+        key.endsWith(' ') ||
+        key === '' ||
+        /^\d/.test(key);
+    return needsQuoting ? `"${key}"` : key;
+}

package/dist/utils/url.d.ts

@@ -0,0 +1,10 @@
+export declare function isUrl(str: string): boolean;
+export declare function resolveUrl(base: string, ref: string): string;
+export declare function parseJsonPointer(pointer: string): string[];
+export declare function pathSegments(path: string): string[];
+export declare function getPathSegmentsWithParamInfo(path: string): Array<{
+    segment: string;
+    isParam: boolean;
+}>;
+export declare function isPathParam(segment: string): boolean;
+export declare function extractParamName(segment: string): string;

package/dist/utils/url.js

@@ -0,0 +1,40 @@
+export function isUrl(str) {
+    return str.startsWith('http://') || str.startsWith('https://');
+}
+export function resolveUrl(base, ref) {
+    if (ref.startsWith('#')) {
+        return base + ref;
+    }
+    if (ref.startsWith('/')) {
+        return ref;
+    }
+    return base + ref;
+}
+export function parseJsonPointer(pointer) {
+    if (pointer === '') {
+        return [];
+    }
+    const segments = pointer.split('/').slice(1);
+    return segments.map((segment) => {
+        return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+    });
+}
+export function pathSegments(path) {
+    return path.split(/[/:]/).filter((segment) => segment.length > 0);
+}
+export function getPathSegmentsWithParamInfo(path) {
+    const segments = path.split(/[/:]/).filter((segment) => segment.length > 0);
+    return segments.map((segment) => ({
+        segment,
+        isParam: segment.startsWith('{') && segment.endsWith('}'),
+    }));
+}
+export function isPathParam(segment) {
+    return segment.startsWith('{') && segment.endsWith('}');
+}
+export function extractParamName(segment) {
+    if (!isPathParam(segment)) {
+        throw new Error(`Segment is not a path parameter: ${segment}`);
+    }
+    return segment.slice(1, -1);
+}