vovk-cli 0.0.1-draft.266 → 0.0.1-draft.268

package/client-templates/mixins/mixins.d.ts.ejs

@@ -8,7 +8,7 @@ export namespace Mixins {
     <% if(segment.meta?.components?.schemas) { %>
       export namespace <%= t._.upperFirst(t._.camelCase(segment.segmentName)) %> {
         <% for (const [componentName, componentSchema] of Object.entries(segment.meta.components.schemas)) { %>
-          <%- await t.compileJSONSchemaToTypeScriptType(componentSchema, componentName, segment.meta.components) %>
+          <%- t.compileJSONSchemaToTypeScriptType(componentSchema, componentName, segment.meta.components, { dontCreateRefTypes: true }) %>
         <% } %>
       }
     <% } %>
@@ -22,11 +22,11 @@ export namespace Types {
         export namespace <%= controllerSchema.rpcModuleName %> {
           <% for (const [handlerName, handlerSchema] of Object.entries(controllerSchema.handlers)) { %>
             export namespace <%= t._.upperFirst(handlerName) %> {
-            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.body, 'Body') %>
-            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.query, 'Query') %>
-            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.params, 'Params') %>
-            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.output, 'Output') %>
-            <%- await t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.iteration,  'Iteration') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.body, 'Body') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.query, 'Query') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.params, 'Params') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.output, 'Output') %>
+            <%- t.compileJSONSchemaToTypeScriptType(handlerSchema.validation?.iteration,  'Iteration') %>
             }
           <% } %>
         }

package/dist/utils/compileJSONSchemaToTypeScriptType.d.mts

@@ -1,3 +1,5 @@
-import { JSONSchema } from 'json-schema-to-typescript';
-import { OpenAPIObject } from 'openapi3-ts/oas31';
-export declare function compileJSONSchemaToTypeScriptType(schema: JSONSchema, typeName: string, components?: NonNullable<OpenAPIObject['components']>): Promise<string>;
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { JSONSchema7 } from 'json-schema';
+export declare function compileJSONSchemaToTypeScriptType(schema: JSONSchema7, typeName: string, components?: NonNullable<OpenAPIObject['components']>, options?: {
+    dontCreateRefTypes?: boolean;
+}): string;

package/dist/utils/compileJSONSchemaToTypeScriptType.mjs

@@ -1,39 +1,9 @@
-import { compile } from 'json-schema-to-typescript';
-function replaceUnresolvedRefs(schema, components) {
-    if (schema === null || typeof schema !== 'object') {
-        return schema;
-    }
-    if (typeof schema.$ref === 'string') {
-        const refPath = schema.$ref.split('/');
-        const componentName = refPath[refPath.length - 1];
-        if (!(componentName in (components.schemas ?? schema.$defs ?? schema.definitions ?? {}))) {
-            return {
-                tsType: `unknown`,
-            };
-        }
-    }
-    if (Array.isArray(schema)) {
-        return schema.map((item) => replaceUnresolvedRefs(item, components));
-    }
-    else {
-        const result = {};
-        for (const [key, value] of Object.entries(schema)) {
-            result[key] = replaceUnresolvedRefs(value, components);
-        }
-        return result;
-    }
-}
-export async function compileJSONSchemaToTypeScriptType(schema, typeName, components = {}) {
+import { compileTs } from './compileTs.mjs';
+export function compileJSONSchemaToTypeScriptType(schema, typeName, components = {}, options = {}) {
     if (!schema)
         return '';
     if ('tsType' in schema && typeof schema.tsType === 'string')
         return `export type ${typeName} = ${schema.tsType};\n`;
-    schema = replaceUnresolvedRefs(schema, components);
-    components = replaceUnresolvedRefs(components, components);
-    // tsType attribute isn't working with objects that use $ref, so we need to handle it separately
-    const tsType = await compile({ ...schema, components }, typeName, {
-        bannerComment: schema.description ? `/**\n * ${schema.description}\n */` : '',
-        ignoreMinAndMaxItems: true,
-    });
+    const tsType = compileTs({ schema: { ...schema, components }, name: typeName, ...options });
     return tsType;
 }

package/dist/utils/compileTs.d.mts

@@ -0,0 +1,12 @@
+import { JSONSchema7 } from 'json-schema';
+import { OpenAPIObject } from 'openapi3-ts/oas31';
+interface CompileOptions {
+    name: string;
+    schema: JSONSchema7 & {
+        components?: OpenAPIObject['components'];
+    };
+    refs?: Map<string, JSONSchema7>;
+    dontCreateRefTypes?: boolean;
+}
+export declare function compileTs(options: CompileOptions): string;
+export {};

package/dist/utils/compileTs.mjs

@@ -0,0 +1,245 @@
+export function compileTs(options) {
+    const context = {
+        refs: options.refs || new Map(),
+        compiledRefs: new Map(),
+        refsInProgress: new Set(),
+    };
+    // Collect all definitions from the schema
+    collectDefinitions(options.schema, context.refs);
+    const mainType = compileSchema(options.schema, options.name, context);
+    // Compile all referenced types, unless dontCreateRefTypes is set
+    const compiledRefs = options.dontCreateRefTypes
+        ? ''
+        : Array.from(context.compiledRefs.entries())
+            .map(([, typeDecl]) => typeDecl)
+            .join('\n\n');
+    return compiledRefs
+        ? `${compiledRefs}\n\n${options.schema.description ? `/** ${options.schema.description} */\n` : ''}export type ${options.name} = ${mainType};`
+        : `${options.schema.description ? `/** ${options.schema.description} */\n` : ''}export type ${options.name} = ${mainType};`;
+}
+function collectDefinitions(schema, refs) {
+    // Collect from $defs
+    if (schema.$defs) {
+        Object.entries(schema.$defs).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/$defs/${key}`, def);
+            }
+        });
+    }
+    // Collect from definitions (older spec)
+    if (schema.definitions) {
+        Object.entries(schema.definitions).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/definitions/${key}`, def);
+            }
+        });
+    }
+    // Collect from components/schemas (OpenAPI spec)
+    if (schema?.components?.schemas) {
+        Object.entries(schema?.components?.schemas ?? {}).forEach(([key, def]) => {
+            if (typeof def === 'object') {
+                refs.set(`#/components/schemas/${key}`, def);
+            }
+        });
+    }
+    // Recursively collect from nested schemas
+    const schemasToProcess = [];
+    if (schema.properties) {
+        schemasToProcess.push(...Object.values(schema.properties).filter(isSchema));
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schemasToProcess.push(...schema.items.filter(isSchema));
+        }
+        else if (isSchema(schema.items)) {
+            schemasToProcess.push(schema.items);
+        }
+    }
+    if (schema.additionalProperties && isSchema(schema.additionalProperties)) {
+        schemasToProcess.push(schema.additionalProperties);
+    }
+    if (schema.allOf)
+        schemasToProcess.push(...schema.allOf.filter(isSchema));
+    if (schema.anyOf)
+        schemasToProcess.push(...schema.anyOf.filter(isSchema));
+    if (schema.oneOf)
+        schemasToProcess.push(...schema.oneOf.filter(isSchema));
+    schemasToProcess.forEach((s) => collectDefinitions(s, refs));
+}
+function isSchema(value) {
+    return typeof value === 'object' && !Array.isArray(value);
+}
+function compileSchema(schema, name, context) {
+    if (typeof schema === 'boolean') {
+        return schema ? 'any' : 'never';
+    }
+    // Handle x-tsType extension
+    if ('x-tsType' in schema && typeof schema['x-tsType'] === 'string') {
+        return schema['x-tsType'];
+    }
+    // Handle $ref
+    if (schema.$ref) {
+        return handleRef(schema.$ref, context);
+    }
+    // Handle combinators
+    if (schema.allOf) {
+        return handleAllOf(schema.allOf, name, context);
+    }
+    if (schema.anyOf) {
+        return handleAnyOf(schema.anyOf, name, context);
+    }
+    if (schema.oneOf) {
+        return handleOneOf(schema.oneOf, name, context);
+    }
+    // Handle type-specific compilation
+    if (schema.enum) {
+        return handleEnum(schema.enum);
+    }
+    if (schema.const !== undefined) {
+        return handleConst(schema.const);
+    }
+    if (!schema.type) {
+        // No type specified, could be object
+        if (schema.properties || schema.additionalProperties) {
+            return handleObject(schema, name, context);
+        }
+        return 'any';
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.map((t) => compileSchemaWithType({ ...schema, type: t }, name, context)).join(' | ');
+    }
+    return compileSchemaWithType(schema, name, context);
+}
+function compileSchemaWithType(schema, name, context) {
+    switch (schema.type) {
+        case 'null':
+            return 'null';
+        case 'boolean':
+            return 'boolean';
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'integer':
+            return 'number';
+        case 'array':
+            return handleArray(schema, name, context);
+        case 'object':
+            return handleObject(schema, name, context);
+        default:
+            return 'any';
+    }
+}
+function handleRef(ref, context) {
+    const typeName = refToTypeName(ref);
+    // Check if we're already compiling this ref (circular reference)
+    if (context.refsInProgress.has(ref)) {
+        return typeName;
+    }
+    // Check if already compiled
+    if (context.compiledRefs.has(ref)) {
+        return typeName;
+    }
+    // Find the referenced schema
+    const referencedSchema = context.refs.get(ref);
+    if (!referencedSchema) {
+        return 'any'; // Reference not found
+    }
+    // Mark as in progress
+    context.refsInProgress.add(ref);
+    // Compile the referenced schema
+    const compiledType = compileSchema(referencedSchema, typeName, context);
+    const description = referencedSchema.description ? `/** ${referencedSchema.description} */\n` : '';
+    context.compiledRefs.set(ref, `${description}export type ${typeName} = ${compiledType};`);
+    // Mark as completed
+    context.refsInProgress.delete(ref);
+    return typeName;
+}
+function handleAllOf(schemas, name, context) {
+    const types = schemas.map((s, i) => compileSchema(s, `${name}AllOf${i}`, context));
+    // For allOf, we need to intersect types
+    // If they're all objects, we can merge them properly
+    const objectTypes = types.filter((t) => t.startsWith('{') && t.endsWith('}'));
+    if (objectTypes.length === types.length) {
+        // Merge object types
+        const merged = objectTypes.map((t) => t.slice(1, -1).trim()).filter((t) => t.length > 0);
+        return merged.length > 0 ? `{ ${merged.join('; ')} }` : '{}';
+    }
+    return types.join(' & ');
+}
+function handleAnyOf(schemas, name, context) {
+    const types = schemas.map((s, i) => compileSchema(s, `${name}AnyOf${i}`, context));
+    return types.join(' | ');
+}
+function handleOneOf(schemas, name, context) {
+    // For TypeScript, oneOf behaves like anyOf
+    const types = schemas.map((s, i) => compileSchema(s, `${name}OneOf${i}`, context));
+    return types.join(' | ');
+}
+function handleEnum(enumValues) {
+    return enumValues.map((v) => JSON.stringify(v)).join(' | ');
+}
+function handleConst(value) {
+    return JSON.stringify(value);
+}
+function handleArray(schema, name, context) {
+    if (!schema.items) {
+        return 'any[]';
+    }
+    if (Array.isArray(schema.items)) {
+        // Tuple (ignoring min/max as requested)
+        const types = schema.items.map((item, i) => compileSchema(item, `${name}Item${i}`, context));
+        return `[${types.join(', ')}]`;
+    }
+    const itemType = compileSchema(schema.items, `${name}Item`, context);
+    return `${wrapUnionType(itemType)}[]`;
+}
+function handleObject(schema, name, context) {
+    const props = [];
+    // Handle known properties
+    if (schema.properties) {
+        const required = new Set(schema.required || []);
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            if (!isSchema(propSchema))
+                continue;
+            const isRequired = required.has(propName);
+            const propType = compileSchema(propSchema, `${name}${capitalize(propName)}`, context);
+            const safePropName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName) ? propName : `"${propName}"`;
+            // Add JSDoc comment if description is present
+            const comment = propSchema.description ? `\n/** ${propSchema.description} */\n` : '';
+            props.push(`${comment}${safePropName}${isRequired ? '' : '?'}: ${propType}`);
+        }
+    }
+    // Handle additional properties
+    if (schema.additionalProperties === true) {
+        props.push('[key: string]: any');
+    }
+    else if (schema.additionalProperties && isSchema(schema.additionalProperties)) {
+        const additionalType = compileSchema(schema.additionalProperties, `${name}Additional`, context);
+        props.push(`[key: string]: ${additionalType}`);
+    }
+    // Handle pattern properties
+    if (schema.patternProperties) {
+        // For simplicity, treat pattern properties as string index signature
+        const patternTypes = Object.values(schema.patternProperties)
+            .filter(isSchema)
+            .map((s, i) => compileSchema(s, `${name}Pattern${i}`, context));
+        if (patternTypes.length > 0) {
+            props.push(`[key: string]: ${patternTypes.join(' | ')}`);
+        }
+    }
+    return props.length > 0 ? `{ ${props.join('; ')} }` : '{}';
+}
+function refToTypeName(ref) {
+    // Extract the last part of the reference as the type name
+    const parts = ref.split('/');
+    const name = parts[parts.length - 1];
+    return capitalize(name);
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function wrapUnionType(type) {
+    // Wrap union types in parentheses for array types
+    return type.includes('|') ? `(${type})` : type;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vovk-cli",
-  "version": "0.0.1-draft.266",
+  "version": "0.0.1-draft.268",
   "bin": {
     "vovk": "./dist/index.mjs"
   },