json2jsii - npm Package Compare versions

Comparing version 0.1.103 to 0.1.104

CHANGELOG.md

@@ -5,2 +5,9 @@ # Changelog
 
+### 0.1.104 (2020-11-16)
+
+
+### Features
+
+* type aliases ([#183](https://github.com/aws/json2jsii/issues/183)) ([d39695d](https://github.com/aws/json2jsii/commit/d39695dcdef3a6cee0723b28d0d85e1868a56200)), closes [awslabs/cdk8s#370](https://github.com/awslabs/cdk8s/issues/370)
+
 ### 0.1.103 (2020-11-16)
@@ -7,0 +14,0 @@

lib/type-generator.d.ts

@@ -37,14 +37,45 @@ import { JSONSchema4 } from 'json-schema';
     /**
-     * Emit a type based on a JSON schema.
+     * Adds a JSON schema definition for a type name. This method does not emit the type
+     * but rather just registers the definition that will get resolved if this type is `$ref`ed.
+     *
+     * @param typeName The name of the type.
+     * @param def The JSON schema definition for this type
+     */
+    addDefinition(typeName: string, def: JSONSchema4): void;
+    /**
+     * Overrides the definition of `fromTypeName` such that any references to it
+     * will be resolved as `toTypeName`. Bear in mind that the type name specified
+     * in `to` must either be defined as a definition (`addDefinition()`) _or_
+     * emitted as a custom type (`emitCustomType()`).
+     */
+    addAlias(from: string, to: string): void;
+    /**
+     * Emit a type based on a JSON schema. If `def` is not specified, the
+     * definition of the type will be looked up in the `definitions` provided
+     * during initialization or via `addDefinition()`.
+     *
      * @param typeName The name of th type
-     * @param def JSON schema
+     * @param def JSON schema. If not specified, the schema is looked up from
+     * `definitions` based on the type name
      * @param structFqn FQN for the type (defaults to `typeName`)
+     * @returns The resolved type (not always the same as `typeName`)
      */
-    addType(typeName: string, def: JSONSchema4, structFqn?: string): string;
+    emitType(typeName: string, def?: JSONSchema4, structFqn?: string): string;
     /**
-     * Emits code once to the output file.
-     * @param uniqueid A unique identifier for the code snippet (e.g. the name of the type)
-     * @param codeEmitter A function that will be called to emit the code.
+     * Registers a custom type and emits it. This will override any existing
+     * definitions for this type name.
+     *
+     * @param typeName The name of the type emitted by this handler.
+     * @param emitter A function that will be called to emit the code.
      */
-    addCode(uniqueid: string, codeEmitter: (code: Code) => void): void;
+    emitCustomType(typeName: string, emitter: (code: Code) => void): void;
+    /**
+     * @deprecated use `emitCustomType()`
+     */
+    addCode(typeName: string, codeEmitter: (code: Code) => void): void;
+    /**
+     * Renders all emitted types to a string.
+     *
+     * Use `renderToCode()` in order to render output to an existing `Code` object.
+     */
     render(): string;
@@ -56,4 +87,12 @@ /**
      */
+    renderToCode(code: Code): void;
+    /**
+     * @deprecated use `renderToCode()`
+     */
     emitCode(code: Code): void;
     /**
+     * @deprecated use `emitType()`
+     */
+    addType(typeName: string, def?: JSONSchema4, structFqn?: string): string;
+    /**
      * @returns true if this definition can be represented as a union or false if it cannot
@@ -60,0 +99,0 @@ */

lib/type-generator.js

@@ -23,3 +23,6 @@ "use strict";
         this.exclude = (_a = options.exclude) !== null && _a !== void 0 ? _a : [];
-        this.definitions = (_b = options.definitions) !== null && _b !== void 0 ? _b : {};
+        this.definitions = {};
+        for (const [typeName, def] of Object.entries((_b = options.definitions) !== null && _b !== void 0 ? _b : {})) {
+            this.addDefinition(typeName, def);
+        }
     }
@@ -49,8 +52,38 @@ /**
     /**
-     * Emit a type based on a JSON schema.
+     * Adds a JSON schema definition for a type name. This method does not emit the type
+     * but rather just registers the definition that will get resolved if this type is `$ref`ed.
+     *
+     * @param typeName The name of the type.
+     * @param def The JSON schema definition for this type
+     */
+    addDefinition(typeName, def) {
+        this.definitions[typeName] = def;
+    }
+    /**
+     * Overrides the definition of `fromTypeName` such that any references to it
+     * will be resolved as `toTypeName`. Bear in mind that the type name specified
+     * in `to` must either be defined as a definition (`addDefinition()`) _or_
+     * emitted as a custom type (`emitCustomType()`).
+     */
+    addAlias(from, to) {
+        this.addDefinition(from, { $ref: `#/definitions/${to}` });
+    }
+    /**
+     * Emit a type based on a JSON schema. If `def` is not specified, the
+     * definition of the type will be looked up in the `definitions` provided
+     * during initialization or via `addDefinition()`.
+     *
      * @param typeName The name of th type
-     * @param def JSON schema
+     * @param def JSON schema. If not specified, the schema is looked up from
+     * `definitions` based on the type name
      * @param structFqn FQN for the type (defaults to `typeName`)
+     * @returns The resolved type (not always the same as `typeName`)
      */
-    addType(typeName, def, structFqn = typeName) {
+    emitType(typeName, def, structFqn = typeName) {
+        if (!def) {
+            def = this.definitions[typeName];
+            if (!def) {
+                throw new Error(`unable to find schema definition for ${typeName}`);
+            }
+        }
         // callers expect that emit a type named `typeName` so we can't change it here
@@ -110,15 +143,28 @@ // but at least we can verify it's correct.
     /**
-     * Emits code once to the output file.
-     * @param uniqueid A unique identifier for the code snippet (e.g. the name of the type)
-     * @param codeEmitter A function that will be called to emit the code.
+     * Registers a custom type and emits it. This will override any existing
+     * definitions for this type name.
+     *
+     * @param typeName The name of the type emitted by this handler.
+     * @param emitter A function that will be called to emit the code.
      */
-    addCode(uniqueid, codeEmitter) {
-        if (this.emittedTypes.has(uniqueid)) {
+    emitCustomType(typeName, emitter) {
+        if (this.emittedTypes.has(typeName)) {
             return;
         }
-        this.typesToEmit[uniqueid] = codeEmitter;
+        this.typesToEmit[typeName] = emitter;
     }
+    /**
+     * @deprecated use `emitCustomType()`
+     */
+    addCode(typeName, codeEmitter) {
+        return this.emitCustomType(typeName, codeEmitter);
+    }
+    /**
+     * Renders all emitted types to a string.
+     *
+     * Use `renderToCode()` in order to render output to an existing `Code` object.
+     */
     render() {
         const code = new code_1.Code();
-        this.emitCode(code);
+        this.renderToCode(code);
         return code.render();
@@ -131,3 +177,3 @@ }
      */
-    emitCode(code) {
+    renderToCode(code) {
         while (Object.keys(this.typesToEmit).length) {
@@ -143,2 +189,14 @@ const name = Object.keys(this.typesToEmit)[0];
     /**
+     * @deprecated use `renderToCode()`
+     */
+    emitCode(code) {
+        return this.renderToCode(code);
+    }
+    /**
+     * @deprecated use `emitType()`
+     */
+    addType(typeName, def, structFqn = typeName) {
+        return this.emitType(typeName, def, structFqn);
+    }
+    /**
      * @returns true if this definition can be represented as a union or false if it cannot
@@ -250,3 +308,3 @@ */
         const subtype = TypeGenerator.normalizeTypeName(propertyFqn.split('.').map(x => pascalCase(x)).join(''));
-        return this.addType(subtype, def, subtype);
+        return this.emitType(subtype, def, subtype);
     }
@@ -263,4 +321,8 @@ typeForRef(def) {
         const typeName = TypeGenerator.normalizeTypeName(comps[comps.length - 1]);
+        // if we already emitted a type with this type name, just return it
+        if (this.emittedTypes.has(typeName)) {
+            return typeName;
+        }
         const schema = this.resolveReference(def);
-        return this.addType(typeName, schema, def.$ref);
+        return this.emitType(typeName, schema, def.$ref);
     }
@@ -305,2 +367,2 @@ typeForArray(propertyFqn, def) {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-generator.js","sourceRoot":"","sources":["../src/type-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import * as camelCase from 'camelcase';\nimport { JSONSchema4 } from 'json-schema';\nimport { snakeCase } from 'snake-case';\nimport { Code } from './code';\n\n\nconst PRIMITIVE_TYPES = ['string', 'number', 'integer', 'boolean'];\nconst DEFINITIONS_PREFIX = '#/definitions/';\n\nexport interface TypeGeneratorOptions {\n  /**\n   * Patterns of type FQNs to exclude.\n   * @default - include all types\n   */\n  readonly exclude?: string[];\n\n  /**\n   * Schema definitions for resolving $refs\n   * @default - $refs are not supported\n   */\n  readonly definitions?: { [def: string]: JSONSchema4 };\n}\n\n/**\n * Generates typescript types from JSON schemas.\n */\nexport class TypeGenerator {\n\n  /**\n   * Convert all-caps acronyms (e.g. \"VPC\", \"FooBARZooFIGoo\") to pascal case\n   * (e.g. \"Vpc\", \"FooBarZooFiGoo\").\n   */\n  public static normalizeTypeName(typeName: string) {\n    // start with the full string and then use the regex to match all-caps sequences.\n    const re = /([A-Z]+)(?:[^a-z]|$)/g;\n    let result = typeName;\n    let m;\n    do {\n      m = re.exec(typeName);\n      if (m) {\n        const before = result.slice(0, m.index); // all the text before the sequence\n        const cap = m[1]; // group #1 matches the all-caps sequence we are after\n        const pascal = cap[0] + cap.slice(1).toLowerCase(); // convert to pascal case by lowercasing all but the first char\n        const after = result.slice(m.index + pascal.length); // all the text after the sequence\n        result = before + pascal + after; // concat\n      }\n    } while (m);\n\n    result = result.replace(/^./, result[0].toUpperCase()); // ensure first letter is capitalized\n    return result;\n  }\n\n  private readonly typesToEmit: { [name: string]: (code: Code) => void } = { };\n  private readonly emittedTypes = new Set<string>();\n  private readonly exclude: string[];\n  private readonly definitions: { [def: string]: JSONSchema4 };\n\n  /**\n   *\n   * @param schema Schema definitions\n   * @param options\n   */\n  constructor(options: TypeGeneratorOptions = { }) {\n    this.exclude = options.exclude ?? [];\n    this.definitions = options.definitions ?? { };\n  }\n\n  /**\n   * Emit a type based on a JSON schema.\n   * @param typeName The name of th type\n   * @param def JSON schema\n   * @param structFqn FQN for the type (defaults to `typeName`)\n   */\n  public addType(typeName: string, def: JSONSchema4, structFqn: string = typeName): string {\n    // callers expect that emit a type named `typeName` so we can't change it here\n    // but at least we can verify it's correct.\n    if (TypeGenerator.normalizeTypeName(typeName) !== typeName) {\n      throw new Error(`${typeName} must be normalized before calling emitType`);\n    }\n\n    if (structFqn.startsWith(DEFINITIONS_PREFIX)) {\n      structFqn = structFqn.substring(DEFINITIONS_PREFIX.length);\n    }\n\n    if (this.isExcluded(structFqn)) {\n      throw new Error(`Type ${structFqn} cannot be added since it matches one of the exclusion patterns`);\n    }\n\n    if (def.$ref) {\n      return this.typeForRef(def);\n    }\n\n    // unions (unless this is a struct, and then we just ignore the constraints)\n    if (def.oneOf || def.anyOf) {\n      if (this.emitUnion(typeName, def, structFqn)) {\n        return typeName;\n      }\n\n      // carry on, we can't represent this schema as a union (yet?)\n    }\n\n    if (def.type === 'string' && def.format === 'date-time') {\n      return 'Date';\n    }\n\n    switch (def.type) {\n      case 'boolean': return 'boolean';\n      case 'array': return `${this.typeForArray(typeName, def)}[]`;\n      case 'any': return 'any';\n      case 'null': return 'any';\n    }\n\n    if (def.type === 'number' || def.type === 'integer') {\n      return 'number';\n    }\n\n    if (def.type === 'string') {\n      if (def.format === 'date-time') {\n        return 'Date';\n      }\n\n      if (Array.isArray(def.enum) && def.enum.length > 0 && !def.enum.find(x => typeof(x) !== 'string')) {\n        return this.emitEnum(typeName, def, structFqn);\n      }\n\n      return 'string';\n    }\n\n    // map\n    if (!def.properties && def.additionalProperties && typeof(def.additionalProperties) === 'object') {\n      return `{ [key: string]: ${this.typeForProperty(typeName, def.additionalProperties)} }`;\n    }\n\n    // struct\n    if (def.properties) {\n      this.emitStruct(typeName, def, structFqn);\n      return typeName;\n    }\n\n    return 'any';\n  }\n\n  /**\n   * Emits code once to the output file.\n   * @param uniqueid A unique identifier for the code snippet (e.g. the name of the type)\n   * @param codeEmitter A function that will be called to emit the code.\n   */\n  public addCode(uniqueid: string, codeEmitter: (code: Code) => void) {\n    if (this.emittedTypes.has(uniqueid)) {\n      return;\n    }\n\n    this.typesToEmit[uniqueid] = codeEmitter;\n  }\n\n  public render() {\n    const code = new Code();\n    this.emitCode(code);\n    return code.render();\n  }\n\n  /**\n   * Writes all types to a `CodeMaker` with an open file.\n   * Use this method in case you need to add those type to an existing file.\n   * @param code The `CodeMaker` instance.\n   */\n  public emitCode(code: Code) {\n    while (Object.keys(this.typesToEmit).length) {\n      const name = Object.keys(this.typesToEmit)[0];\n      const emitter = this.typesToEmit[name];\n      emitter(code);\n      code.line();\n      delete this.typesToEmit[name];\n      this.emittedTypes.add(name);\n    }\n  }\n  /**\n   * @returns true if this definition can be represented as a union or false if it cannot\n   */\n  private emitUnion(typeName: string, def: JSONSchema4, fqn: string) {\n    const options = new Array<string>();\n    for (const option of def.oneOf || def.anyOf || []) {\n      if (!supportedUnionOptionType(option.type)) {\n        return false;\n      }\n\n      const type = option.type === 'integer' ? 'number' : option.type;\n      options.push(type);\n    }\n\n    this.addCode(typeName, code => {\n      this.emitDescription(code, fqn, def.description);\n\n      code.openBlock(`export class ${typeName}`);\n\n      for (const type of options) {\n        const methodName = 'from' + type[0].toUpperCase() + type.substr(1);\n        code.openBlock(`public static ${methodName}(value: ${type}): ${typeName}`);\n        code.line(`return new ${typeName}(value);`);\n        code.closeBlock();\n      }\n\n      code.openBlock('private constructor(value: any)');\n      code.line('Object.defineProperty(this, \\'resolve\\', { value: () => value });');\n      code.closeBlock();\n\n      code.closeBlock();\n    });\n\n    return true;\n  }\n\n  private emitStruct(typeName: string, structDef: JSONSchema4, structFqn: string) {\n    this.addCode(typeName, code => {\n      this.emitDescription(code, structFqn, structDef.description);\n      code.openBlock(`export interface ${typeName}`);\n\n      for (const [propName, propSpec] of Object.entries(structDef.properties || {})) {\n\n        if (propName.startsWith('x-')) {\n          continue; // skip extensions for now\n        }\n\n        if (propName.includes('_')) {\n          console.error(`warning: property ${structFqn}.${propName} omitted since it includes an underscore`);\n          continue; // skip\n        }\n\n        this.emitProperty(code, propName, propSpec, structFqn, structDef);\n      }\n\n      code.closeBlock();\n    });\n  }\n\n  private emitProperty(code: Code, name: string, propDef: JSONSchema4, structFqn: string, structDef: JSONSchema4) {\n    const originalName = name;\n\n    // if name is not camelCase, convert it to camel case, but this is likely to\n    // produce invalid output during synthesis, so add some annotation to the docs.\n    if (name[0] === name[0].toUpperCase()) {\n      name = camelCase(name);\n    }\n\n    // if the name starts with '$' (like $ref or $schema), we remove the \"$\"\n    // and it's the same deal - will produce invalid output\n    if (name.startsWith('$')) {\n      name = name.substring(1);\n    }\n\n    this.emitDescription(code, `${structFqn}#${originalName}`, propDef.description);\n    const propertyType = this.typeForProperty(`${structFqn}.${name}`, propDef);\n    const required = this.isPropertyRequired(name, structDef);\n    const optional = required ? '' : '?';\n\n    code.line(`readonly ${name}${optional}: ${propertyType};`);\n    code.line();\n  }\n\n  private emitEnum(typeName: string, def: JSONSchema4, structFqn: string) {\n\n    this.addCode(typeName, code => {\n\n      if (!def.enum || def.enum.length === 0) {\n        throw new Error(`definition is not an enum: ${JSON.stringify(def)}`);\n      }\n\n      if (def.type !== 'string') {\n        throw new Error('can only generate string enums');\n      }\n\n      this.emitDescription(code, structFqn, def.description);\n\n      code.openBlock(`export enum ${typeName}`);\n\n      for (const value of def.enum) {\n        if (typeof(value) !== 'string') {\n          throw new Error('can only generate enums for string values');\n        }\n\n        // sluggify and turn to UPPER_SNAKE_CASE\n        const memberName = snakeCase(value.replace(/[^a-z0-9]/gi, '_')).split('_').filter(x => x).join('_').toUpperCase();\n\n        code.line(`/** ${value} */`);\n        code.line(`${memberName} = \"${value}\",`);\n      }\n\n      code.closeBlock();\n    });\n\n    return typeName;\n  }\n\n  private emitDescription(code: Code, fqn: string, description?: string, annotations: { [type: string]: string } = { }) {\n    code.line('/**');\n\n    if (description) {\n      description = description.replace(/\\*\\//g, '_/');\n\n      const extractDefault = /Defaults?\\W+(to|is)\\W+(.+)/g.exec(description);\n      const def = extractDefault && extractDefault[2];\n\n      code.line(` * ${description}`);\n      if (def) {\n        annotations.default = def;\n      }\n\n      code.line(' *');\n    }\n\n    annotations.schema = fqn;\n\n    for (const [type, value] of Object.entries(annotations)) {\n      code.line(` * @${type} ${value}`);\n    }\n\n    code.line(' */');\n  }\n\n  private typeForProperty(propertyFqn: string, def: JSONSchema4): string {\n    const subtype = TypeGenerator.normalizeTypeName(propertyFqn.split('.').map(x => pascalCase(x)).join(''));\n    return this.addType(subtype, def, subtype);\n  }\n\n  private typeForRef(def: JSONSchema4): string {\n    const prefix = '#/definitions/';\n    if (!def.$ref || !def.$ref.startsWith(prefix)) {\n      throw new Error(`invalid $ref ${JSON.stringify(def)}`);\n    }\n\n    if (this.isExcluded(def.$ref)) {\n      return 'any';\n    }\n\n    const comps = def.$ref.substring(prefix.length).split('.');\n    const typeName = TypeGenerator.normalizeTypeName(comps[comps.length - 1]);\n    const schema = this.resolveReference(def);\n    return this.addType(typeName, schema, def.$ref);\n  }\n\n  private typeForArray(propertyFqn: string, def: JSONSchema4): string {\n    if (!def.items || typeof(def.items) !== 'object') {\n      throw new Error(`unsupported array type ${def.items}`);\n    }\n\n    return this.typeForProperty(propertyFqn, def.items);\n  }\n\n  private resolveReference(def: JSONSchema4): JSONSchema4 {\n    const ref = def.$ref;\n    if (!ref || !ref.startsWith(DEFINITIONS_PREFIX)) {\n      throw new Error('expecting a local reference');\n    }\n\n    const lookup = ref.substr(DEFINITIONS_PREFIX.length);\n    const found = this.definitions[lookup];\n    if (!found) {\n      throw new Error(`unable to find a definition for the $ref \"${lookup}\"`);\n    }\n\n    return found;\n  }\n\n  private isPropertyRequired(property: string, structDef: JSONSchema4) {\n    return Array.isArray(structDef.required) && structDef.required.includes(property);\n  }\n\n  private isExcluded(fqn: string) {\n    for (const pattern of this.exclude) {\n      const re = new RegExp(pattern);\n      if (re.test(fqn)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n\nfunction supportedUnionOptionType(type: any): type is string {\n  return type && (typeof(type) === 'string' && PRIMITIVE_TYPES.includes(type));\n}\n\nfunction pascalCase(s: string): string {\n  return camelCase(s, { pascalCase: true });\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-generator.js","sourceRoot":"","sources":["../src/type-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import * as camelCase from 'camelcase';\nimport { JSONSchema4 } from 'json-schema';\nimport { snakeCase } from 'snake-case';\nimport { Code } from './code';\n\n\nconst PRIMITIVE_TYPES = ['string', 'number', 'integer', 'boolean'];\nconst DEFINITIONS_PREFIX = '#/definitions/';\n\nexport interface TypeGeneratorOptions {\n  /**\n   * Patterns of type FQNs to exclude.\n   * @default - include all types\n   */\n  readonly exclude?: string[];\n\n  /**\n   * Schema definitions for resolving $refs\n   * @default - $refs are not supported\n   */\n  readonly definitions?: { [def: string]: JSONSchema4 };\n}\n\n/**\n * Generates typescript types from JSON schemas.\n */\nexport class TypeGenerator {\n  /**\n   * Convert all-caps acronyms (e.g. \"VPC\", \"FooBARZooFIGoo\") to pascal case\n   * (e.g. \"Vpc\", \"FooBarZooFiGoo\").\n   */\n  public static normalizeTypeName(typeName: string) {\n    // start with the full string and then use the regex to match all-caps sequences.\n    const re = /([A-Z]+)(?:[^a-z]|$)/g;\n    let result = typeName;\n    let m;\n    do {\n      m = re.exec(typeName);\n      if (m) {\n        const before = result.slice(0, m.index); // all the text before the sequence\n        const cap = m[1]; // group #1 matches the all-caps sequence we are after\n        const pascal = cap[0] + cap.slice(1).toLowerCase(); // convert to pascal case by lowercasing all but the first char\n        const after = result.slice(m.index + pascal.length); // all the text after the sequence\n        result = before + pascal + after; // concat\n      }\n    } while (m);\n\n    result = result.replace(/^./, result[0].toUpperCase()); // ensure first letter is capitalized\n    return result;\n  }\n\n  private readonly typesToEmit: { [name: string]: (code: Code) => void } = { };\n  private readonly emittedTypes = new Set<string>();\n  private readonly exclude: string[];\n  private readonly definitions: { [def: string]: JSONSchema4 };\n\n  /**\n   *\n   * @param schema Schema definitions\n   * @param options\n   */\n  constructor(options: TypeGeneratorOptions = { }) {\n    this.exclude = options.exclude ?? [];\n    this.definitions = {};\n\n    for (const [typeName, def] of Object.entries(options.definitions ?? {})) {\n      this.addDefinition(typeName, def);\n    }\n  }\n\n  /**\n   * Adds a JSON schema definition for a type name. This method does not emit the type\n   * but rather just registers the definition that will get resolved if this type is `$ref`ed.\n   *\n   * @param typeName The name of the type.\n   * @param def The JSON schema definition for this type\n   */\n  public addDefinition(typeName: string, def: JSONSchema4) {\n    this.definitions[typeName] = def;\n  }\n\n  /**\n   * Overrides the definition of `fromTypeName` such that any references to it\n   * will be resolved as `toTypeName`. Bear in mind that the type name specified\n   * in `to` must either be defined as a definition (`addDefinition()`) _or_\n   * emitted as a custom type (`emitCustomType()`).\n   */\n  public addAlias(from: string, to: string) {\n    this.addDefinition(from, { $ref: `#/definitions/${to}` });\n  }\n\n  /**\n   * Emit a type based on a JSON schema. If `def` is not specified, the\n   * definition of the type will be looked up in the `definitions` provided\n   * during initialization or via `addDefinition()`.\n   *\n   * @param typeName The name of th type\n   * @param def JSON schema. If not specified, the schema is looked up from\n   * `definitions` based on the type name\n   * @param structFqn FQN for the type (defaults to `typeName`)\n   * @returns The resolved type (not always the same as `typeName`)\n   */\n  public emitType(typeName: string, def?: JSONSchema4, structFqn: string = typeName): string {\n    if (!def) {\n      def = this.definitions[typeName];\n      if (!def) {\n        throw new Error(`unable to find schema definition for ${typeName}`);\n      }\n    }\n\n    // callers expect that emit a type named `typeName` so we can't change it here\n    // but at least we can verify it's correct.\n    if (TypeGenerator.normalizeTypeName(typeName) !== typeName) {\n      throw new Error(`${typeName} must be normalized before calling emitType`);\n    }\n\n    if (structFqn.startsWith(DEFINITIONS_PREFIX)) {\n      structFqn = structFqn.substring(DEFINITIONS_PREFIX.length);\n    }\n\n    if (this.isExcluded(structFqn)) {\n      throw new Error(`Type ${structFqn} cannot be added since it matches one of the exclusion patterns`);\n    }\n\n    if (def.$ref) {\n      return this.typeForRef(def);\n    }\n\n    // unions (unless this is a struct, and then we just ignore the constraints)\n    if (def.oneOf || def.anyOf) {\n      if (this.emitUnion(typeName, def, structFqn)) {\n        return typeName;\n      }\n\n      // carry on, we can't represent this schema as a union (yet?)\n    }\n\n    if (def.type === 'string' && def.format === 'date-time') {\n      return 'Date';\n    }\n\n    switch (def.type) {\n      case 'boolean': return 'boolean';\n      case 'array': return `${this.typeForArray(typeName, def)}[]`;\n      case 'any': return 'any';\n      case 'null': return 'any';\n    }\n\n    if (def.type === 'number' || def.type === 'integer') {\n      return 'number';\n    }\n\n    if (def.type === 'string') {\n      if (def.format === 'date-time') {\n        return 'Date';\n      }\n\n      if (Array.isArray(def.enum) && def.enum.length > 0 && !def.enum.find(x => typeof(x) !== 'string')) {\n        return this.emitEnum(typeName, def, structFqn);\n      }\n\n      return 'string';\n    }\n\n    // map\n    if (!def.properties && def.additionalProperties && typeof(def.additionalProperties) === 'object') {\n      return `{ [key: string]: ${this.typeForProperty(typeName, def.additionalProperties)} }`;\n    }\n\n    // struct\n    if (def.properties) {\n      this.emitStruct(typeName, def, structFqn);\n      return typeName;\n    }\n\n    return 'any';\n  }\n\n  /**\n   * Registers a custom type and emits it. This will override any existing\n   * definitions for this type name.\n   *\n   * @param typeName The name of the type emitted by this handler.\n   * @param emitter A function that will be called to emit the code.\n   */\n  public emitCustomType(typeName: string, emitter: (code: Code) => void) {\n    if (this.emittedTypes.has(typeName)) {\n      return;\n    }\n\n    this.typesToEmit[typeName] = emitter;\n  }\n\n  /**\n   * @deprecated use `emitCustomType()`\n   */\n  public addCode(typeName: string, codeEmitter: (code: Code) => void) {\n    return this.emitCustomType(typeName, codeEmitter);\n  }\n\n  /**\n   * Renders all emitted types to a string.\n   *\n   * Use `renderToCode()` in order to render output to an existing `Code` object.\n   */\n  public render(): string {\n    const code = new Code();\n    this.renderToCode(code);\n    return code.render();\n  }\n\n  /**\n   * Writes all types to a `CodeMaker` with an open file.\n   * Use this method in case you need to add those type to an existing file.\n   * @param code The `CodeMaker` instance.\n   */\n  public renderToCode(code: Code) {\n    while (Object.keys(this.typesToEmit).length) {\n      const name = Object.keys(this.typesToEmit)[0];\n      const emitter = this.typesToEmit[name];\n      emitter(code);\n      code.line();\n      delete this.typesToEmit[name];\n      this.emittedTypes.add(name);\n    }\n  }\n\n  /**\n   * @deprecated use `renderToCode()`\n   */\n  public emitCode(code: Code) {\n    return this.renderToCode(code);\n  }\n\n  /**\n   * @deprecated use `emitType()`\n   */\n  public addType(typeName: string, def?: JSONSchema4, structFqn: string = typeName): string {\n    return this.emitType(typeName, def, structFqn);\n  }\n\n  /**\n   * @returns true if this definition can be represented as a union or false if it cannot\n   */\n  private emitUnion(typeName: string, def: JSONSchema4, fqn: string) {\n    const options = new Array<string>();\n    for (const option of def.oneOf || def.anyOf || []) {\n      if (!supportedUnionOptionType(option.type)) {\n        return false;\n      }\n\n      const type = option.type === 'integer' ? 'number' : option.type;\n      options.push(type);\n    }\n\n    this.addCode(typeName, code => {\n      this.emitDescription(code, fqn, def.description);\n\n      code.openBlock(`export class ${typeName}`);\n\n      for (const type of options) {\n        const methodName = 'from' + type[0].toUpperCase() + type.substr(1);\n        code.openBlock(`public static ${methodName}(value: ${type}): ${typeName}`);\n        code.line(`return new ${typeName}(value);`);\n        code.closeBlock();\n      }\n\n      code.openBlock('private constructor(value: any)');\n      code.line('Object.defineProperty(this, \\'resolve\\', { value: () => value });');\n      code.closeBlock();\n\n      code.closeBlock();\n    });\n\n    return true;\n  }\n\n  private emitStruct(typeName: string, structDef: JSONSchema4, structFqn: string) {\n    this.addCode(typeName, code => {\n      this.emitDescription(code, structFqn, structDef.description);\n      code.openBlock(`export interface ${typeName}`);\n\n      for (const [propName, propSpec] of Object.entries(structDef.properties || {})) {\n\n        if (propName.startsWith('x-')) {\n          continue; // skip extensions for now\n        }\n\n        if (propName.includes('_')) {\n          console.error(`warning: property ${structFqn}.${propName} omitted since it includes an underscore`);\n          continue; // skip\n        }\n\n        this.emitProperty(code, propName, propSpec, structFqn, structDef);\n      }\n\n      code.closeBlock();\n    });\n  }\n\n  private emitProperty(code: Code, name: string, propDef: JSONSchema4, structFqn: string, structDef: JSONSchema4) {\n    const originalName = name;\n\n    // if name is not camelCase, convert it to camel case, but this is likely to\n    // produce invalid output during synthesis, so add some annotation to the docs.\n    if (name[0] === name[0].toUpperCase()) {\n      name = camelCase(name);\n    }\n\n    // if the name starts with '$' (like $ref or $schema), we remove the \"$\"\n    // and it's the same deal - will produce invalid output\n    if (name.startsWith('$')) {\n      name = name.substring(1);\n    }\n\n    this.emitDescription(code, `${structFqn}#${originalName}`, propDef.description);\n    const propertyType = this.typeForProperty(`${structFqn}.${name}`, propDef);\n    const required = this.isPropertyRequired(name, structDef);\n    const optional = required ? '' : '?';\n\n    code.line(`readonly ${name}${optional}: ${propertyType};`);\n    code.line();\n  }\n\n  private emitEnum(typeName: string, def: JSONSchema4, structFqn: string) {\n\n    this.addCode(typeName, code => {\n\n      if (!def.enum || def.enum.length === 0) {\n        throw new Error(`definition is not an enum: ${JSON.stringify(def)}`);\n      }\n\n      if (def.type !== 'string') {\n        throw new Error('can only generate string enums');\n      }\n\n      this.emitDescription(code, structFqn, def.description);\n\n      code.openBlock(`export enum ${typeName}`);\n\n      for (const value of def.enum) {\n        if (typeof(value) !== 'string') {\n          throw new Error('can only generate enums for string values');\n        }\n\n        // sluggify and turn to UPPER_SNAKE_CASE\n        const memberName = snakeCase(value.replace(/[^a-z0-9]/gi, '_')).split('_').filter(x => x).join('_').toUpperCase();\n\n        code.line(`/** ${value} */`);\n        code.line(`${memberName} = \"${value}\",`);\n      }\n\n      code.closeBlock();\n    });\n\n    return typeName;\n  }\n\n  private emitDescription(code: Code, fqn: string, description?: string, annotations: { [type: string]: string } = { }) {\n    code.line('/**');\n\n    if (description) {\n      description = description.replace(/\\*\\//g, '_/');\n\n      const extractDefault = /Defaults?\\W+(to|is)\\W+(.+)/g.exec(description);\n      const def = extractDefault && extractDefault[2];\n\n      code.line(` * ${description}`);\n      if (def) {\n        annotations.default = def;\n      }\n\n      code.line(' *');\n    }\n\n    annotations.schema = fqn;\n\n    for (const [type, value] of Object.entries(annotations)) {\n      code.line(` * @${type} ${value}`);\n    }\n\n    code.line(' */');\n  }\n\n  private typeForProperty(propertyFqn: string, def: JSONSchema4): string {\n    const subtype = TypeGenerator.normalizeTypeName(propertyFqn.split('.').map(x => pascalCase(x)).join(''));\n    return this.emitType(subtype, def, subtype);\n  }\n\n  private typeForRef(def: JSONSchema4): string {\n    const prefix = '#/definitions/';\n    if (!def.$ref || !def.$ref.startsWith(prefix)) {\n      throw new Error(`invalid $ref ${JSON.stringify(def)}`);\n    }\n\n    if (this.isExcluded(def.$ref)) {\n      return 'any';\n    }\n\n    const comps = def.$ref.substring(prefix.length).split('.');\n    const typeName = TypeGenerator.normalizeTypeName(comps[comps.length - 1]);\n\n    // if we already emitted a type with this type name, just return it\n    if (this.emittedTypes.has(typeName)) {\n      return typeName;\n    }\n\n    const schema = this.resolveReference(def);\n    return this.emitType(typeName, schema, def.$ref);\n  }\n\n  private typeForArray(propertyFqn: string, def: JSONSchema4): string {\n    if (!def.items || typeof(def.items) !== 'object') {\n      throw new Error(`unsupported array type ${def.items}`);\n    }\n\n    return this.typeForProperty(propertyFqn, def.items);\n  }\n\n  private resolveReference(def: JSONSchema4): JSONSchema4 {\n    const ref = def.$ref;\n    if (!ref || !ref.startsWith(DEFINITIONS_PREFIX)) {\n      throw new Error('expecting a local reference');\n    }\n\n    const lookup = ref.substr(DEFINITIONS_PREFIX.length);\n    const found = this.definitions[lookup];\n    if (!found) {\n      throw new Error(`unable to find a definition for the $ref \"${lookup}\"`);\n    }\n\n    return found;\n  }\n\n  private isPropertyRequired(property: string, structDef: JSONSchema4) {\n    return Array.isArray(structDef.required) && structDef.required.includes(property);\n  }\n\n  private isExcluded(fqn: string) {\n    for (const pattern of this.exclude) {\n      const re = new RegExp(pattern);\n      if (re.test(fqn)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n}\n\nfunction supportedUnionOptionType(type: any): type is string {\n  return type && (typeof(type) === 'string' && PRIMITIVE_TYPES.includes(type));\n}\n\nfunction pascalCase(s: string): string {\n  return camelCase(s, { pascalCase: true });\n}"]}

package.json

@@ -124,3 +124,3 @@ {
   },
-  "version": "0.1.103",
+  "version": "0.1.104",
   "jest": {
@@ -127,0 +127,0 @@ "clearMocks": true,

README.md

@@ -27,3 +27,4 @@ # json2jsii
 
-g.addType('Person', {
+// definitions can also be added like this:
+g.addDefinition('Person', {
   required: [ 'name' ],
@@ -42,2 +43,5 @@ properties: {
 
+// this will emit the specified type & recursively all the referenced types.
+g.emitType('Person');
+
 fs.writeFileSync('gen/ts/person.ts', await g.render());
@@ -91,2 +95,31 @@ ```
 
+## Use cases
+
+### Type aliases
+
+It is possible to offer an alias to a type definition using `addAlias(from,
+to)`. The type generator will resolve any references to the original type with
+the alias:
+
+```ts
+const gen = new TypeGenerator();
+gen.addDefinition('TypeA', { type: 'object', properties: { ref: { $ref: '#/definitions/TypeB' } } } );
+gen.addDefinition('TypeC', { type: 'object', properties: { field: { type: 'string' } } });
+gen.addAlias('TypeB', 'TypeC');
+
+gen.emitType('TypeA');
+```
+
+This will output:
+
+```ts
+interface TypeA {
+  readonly ref: TypeC;
+}
+
+interface TypeC {
+  readonly field: string;
+}
+```
+
 ## Language bindings
@@ -93,0 +126,0 @@

version.json

 {
-  "version": "0.1.103"
+  "version": "0.1.104"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

79421

increased by13.43%

Lines of code

530

increased by23.54%

Number of lines in readme file

145

increased by29.46%

No dependency changes