Quicktype TypeScript Input

Common errors

• Error: No inputs were found in config file 'tsconfig.json'

  cause This is a general TypeScript error, often seen when `tsconfig.json`'s `include` or `files` array doesn't match any actual TypeScript files in the project, which can occur during initial setup with `quicktype-typescript-input`.
  fix Ensure your `tsconfig.json`'s `include` or `files` array correctly points to your TypeScript source files, or create at least one `.ts` file matched by the configuration.

• Property 'X' is missing in type 'Y' but required in type 'Z'.

  cause Generated TypeScript types are strict by default. This error indicates that an object or value does not conform to the expected interface or type, commonly due to discrepancies between the input data/schema used for generation and the actual data being processed.
  fix Adjust the input TypeScript source or JSON Schema to accurately reflect all expected properties, including optionality. Alternatively, modify the consuming code to provide all required properties or handle optional properties correctly (e.g., with null checks).

• Uncaught (in promise) Error: Unknown language name: TypeScript

  cause This error occurs in the quicktype web application or similar environments when a stored preference for a target language uses an outdated or incorrect capitalization (e.g., 'TypeScript' instead of 'typescript').
  fix Clear browser data, specifically local storage, for the `quicktype.io` domain. This will reset language preferences to their default, correctly capitalized values.

Warnings

• gotcha When using `quicktype` programmatically or via CLI, type names might sometimes be unpredictably renamed, especially when inferring types from complex schemas or multiple samples. This can lead to inconsistent generated code and requires manual inspection or explicit `--top-level` naming.
  Fix: Specify the top-level type name explicitly using the `--top-level NAME` CLI option or the `typeName` option in programmatic usage to ensure consistent naming. Review generated code for unexpected renamings.
• breaking Older versions of the `quicktype` web interface or cached preferences might store language IDs with capitalization (e.g., 'TypeScript'). Newer versions of `quicktype` expect lowercase language IDs (e.g., 'typescript'), which can cause the application to fail loading due to an 'Unknown language name' error.
  Fix: Clear browser cache and local storage for `app.quicktype.io` or specifically clear the `localStorage` entry for `quicktype` preferences. This forces the application to re-initialize with correct lowercase language IDs.
• gotcha Using `additionalProperties: false` at the root of a JSON Schema in conjunction with `allOf` can lead to unexpected type generation results, as `quicktype` (and JSON Schema validators in general) process these keywords in a way that might not align with intuitive merging behavior.
  Fix: Carefully review the JSON Schema. If `additionalProperties: false` is necessary, ensure that all expected properties, including those from `allOf` subschemas, are explicitly defined or allowed at the root or within the merged schema. Consider removing `additionalProperties: false` if strictness is not paramount or if it conflicts with schema composition.
• deprecated Generating code from TypeScript input via `quicktype` is still considered 'Experimental' according to the main quicktype GitHub README. This implies that the feature might undergo significant changes, could have limitations, or may not be as stable as JSON or JSON Schema inputs.
  Fix: Be aware of potential instabilities or breaking changes. For mission-critical applications, consider converting TypeScript definitions to JSON Schema first, or thoroughly test the generated code for correctness and maintainability. Monitor quicktype's official documentation for updates on this feature's status.

Install

• npm install quicktype-typescript-input npm
• yarn add quicktype-typescript-input yarn
• pnpm add quicktype-typescript-input pnpm

Imports

• quicktype
  wrong:

  import quicktype from 'quicktype';

  correct:

  import { quicktype, InputData } from 'quicktype-core';

  The core quicktype function and InputData are part of 'quicktype-core', not directly 'quicktype-typescript-input'.
• TypeScriptInput
  wrong:

  import { TypeScriptInput } from 'quicktype-core';

  correct:

  import { TypeScriptInput } from 'quicktype-typescript-input';

  This package exports the specific input class for TypeScript source.
• QuicktypeOptions

  import { QuicktypeOptions } from 'quicktype-core';

  For type-checking quicktype configuration options.

Quickstart

This quickstart demonstrates how to programmatically use `quicktype-typescript-input` to take a TypeScript source string defining interfaces and enums, and then generate corresponding type definitions in different target languages like TypeScript or C# using the `quicktype-core` library.

import { quicktype, InputData } from 'quicktype-core';
import { TypeScriptInput } from 'quicktype-typescript-input';

async function generateTypesFromTypeScript(typescriptSource: string, targetLanguage: string, typeName: string): Promise<string> {
  const tsInput = new TypeScriptInput();
  await tsInput.addSource({
    name: typeName,
    samples: new Set([typescriptSource])
  });

  const inputData = new InputData();
  inputData.addInput(tsInput);

  const { lines } = await quicktype({
    inputData,
    lang: targetLanguage,
    typeName,
    rendererOptions: {
      'just-types': 'true' // Common option to only generate types, no serialization code
    }
  });

  return lines.join('\n');
}

const myTypeScriptSource = `
interface User {
  id: string;
  name: string;
  email: string;
  isActive: boolean;
  createdAt: Date;
}

enum UserRole {
  Admin = 'admin',
  Editor = 'editor',
  Viewer = 'viewer',
}
`;

// Example 1: Generate TypeScript interfaces from TypeScript source
generateTypesFromTypeScript(myTypeScriptSource, 'typescript', 'UserAndRole')
  .then(output => {
    console.log('Generated TypeScript:\n', output);
  })
  .catch(error => console.error('Error generating TypeScript:', error));

// Example 2: Generate C# classes from TypeScript source
generateTypesFromTypeScript(myTypeScriptSource, 'csharp', 'UserAndRole')
  .then(output => {
    console.log('\nGenerated C#:\n', output);
  })
  .catch(error => console.error('Error generating C#:', error));