json-schema-to-typescript - npm Package Compare versions

Comparing version 4.6.4 to 4.6.5

dist/src/parser.d.ts

@@ -5,2 +5,3 @@ import { JSONSchema4Type } from 'json-schema';
 export declare type Processed = Map<JSONSchema | JSONSchema4Type, AST>;
-export declare function parse(schema: JSONSchema | JSONSchema4Type, rootSchema?: JSONSchema, keyName?: string, isSchema?: boolean, processed?: Processed): AST;
+export declare type UsedNames = Set<string>;
+export declare function parse(schema: JSONSchema | JSONSchema4Type, rootSchema?: JSONSchema, keyName?: string, isSchema?: boolean, processed?: Processed, usedNames?: Set<string>): AST;

dist/src/parser.js

@@ -16,6 +16,7 @@ "use strict";
 var utils_1 = require("./utils");
-function parse(schema, rootSchema, keyName, isSchema, processed) {
+function parse(schema, rootSchema, keyName, isSchema, processed, usedNames) {
     if (rootSchema === void 0) { rootSchema = schema; }
     if (isSchema === void 0) { isSchema = true; }
     if (processed === void 0) { processed = new Map(); }
+    if (usedNames === void 0) { usedNames = new Set(); }
     // If we've seen this node before, return it.
@@ -34,3 +35,3 @@ if (processed.has(schema)) {
     return isSchema
-        ? parseNonLiteral(schema, rootSchema, keyName, keyNameFromDefinition, set, processed)
+        ? parseNonLiteral(schema, rootSchema, keyName, keyNameFromDefinition, set, processed, usedNames)
         : parseLiteral(schema, keyName, keyNameFromDefinition, set);
@@ -47,3 +48,3 @@ }
 }
-function parseNonLiteral(schema, rootSchema, keyName, keyNameFromDefinition, set, processed) {
+function parseNonLiteral(schema, rootSchema, keyName, keyNameFromDefinition, set, processed, usedNames) {
     utils_1.log(cli_color_1.whiteBright.bgBlue('parser'), schema, '<-' + typeOfSchema_1.typeOfSchema(schema), processed.has(schema) ? '(FROM CACHE)' : '');
@@ -55,4 +56,4 @@ switch (typeOfSchema_1.typeOfSchema(schema)) {
                 keyName: keyName,
-                params: schema.allOf.map(function (_) { return parse(_, rootSchema, undefined, true, processed); }),
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                params: schema.allOf.map(function (_) { return parse(_, rootSchema, undefined, true, processed, usedNames); }),
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'INTERSECTION'
@@ -64,3 +65,3 @@ });
                 keyName: keyName,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'ANY'
@@ -72,4 +73,4 @@ });
                 keyName: keyName,
-                params: schema.anyOf.map(function (_) { return parse(_, rootSchema, undefined, true, processed); }),
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                params: schema.anyOf.map(function (_) { return parse(_, rootSchema, undefined, true, processed, usedNames); }),
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'UNION'
@@ -81,3 +82,3 @@ });
                 keyName: keyName,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'BOOLEAN'
@@ -90,10 +91,10 @@ });
                 params: schema.enum.map(function (_, n) { return ({
-                    ast: parse(_, rootSchema, undefined, false, processed),
+                    ast: parse(_, rootSchema, undefined, false, processed, usedNames),
                     keyName: schema.tsEnumNames[n]
                 }); }),
-                standaloneName: schema.title || keyName,
+                standaloneName: standaloneName(schema, keyName, usedNames),
                 type: 'ENUM'
             });
         case 'NAMED_SCHEMA':
-            return set(newInterface(schema, rootSchema, processed, keyName));
+            return set(newInterface(schema, rootSchema, processed, usedNames, keyName));
         case 'NULL':
@@ -103,3 +104,3 @@ return set({
                 keyName: keyName,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'NULL'
@@ -111,3 +112,3 @@ });
                 keyName: keyName,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'NUMBER'
@@ -119,3 +120,3 @@ });
                 keyName: keyName,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'OBJECT'
@@ -127,4 +128,4 @@ });
                 keyName: keyName,
-                params: schema.oneOf.map(function (_) { return parse(_, rootSchema, undefined, true, processed); }),
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                params: schema.oneOf.map(function (_) { return parse(_, rootSchema, undefined, true, processed, usedNames); }),
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'UNION'
@@ -138,3 +139,3 @@ });
                 keyName: keyName,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'STRING'
@@ -147,4 +148,4 @@ });
                     keyName: keyName,
-                    params: schema.items.map(function (_) { return parse(_, rootSchema, undefined, true, processed); }),
-                    standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                    params: schema.items.map(function (_) { return parse(_, rootSchema, undefined, true, processed, usedNames); }),
+                    standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                     type: 'TUPLE'
@@ -157,4 +158,4 @@ });
                     keyName: keyName,
-                    params: parse(schema.items, rootSchema, undefined, true, processed),
-                    standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                    params: parse(schema.items, rootSchema, undefined, true, processed, usedNames),
+                    standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                     type: 'ARRAY'
@@ -167,4 +168,4 @@ });
                 keyName: keyName,
-                params: schema.type.map(function (_) { return parse({ type: _ }, rootSchema, undefined, true, processed); }),
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                params: schema.type.map(function (_) { return parse({ type: _ }, rootSchema, undefined, true, processed, usedNames); }),
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'UNION'
@@ -176,8 +177,8 @@ });
                 keyName: keyName,
-                params: schema.enum.map(function (_) { return parse(_, rootSchema, undefined, false, processed); }),
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                params: schema.enum.map(function (_) { return parse(_, rootSchema, undefined, false, processed, usedNames); }),
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'UNION'
             });
         case 'UNNAMED_SCHEMA':
-            return set(newInterface(schema, rootSchema, processed, keyName, keyNameFromDefinition));
+            return set(newInterface(schema, rootSchema, processed, usedNames, keyName, keyNameFromDefinition));
         case 'UNTYPED_ARRAY':
@@ -188,3 +189,3 @@ return set({
                 params: AST_1.T_ANY,
-                standaloneName: schema.title || schema.id || keyNameFromDefinition,
+                standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
                 type: 'ARRAY'
@@ -194,13 +195,22 @@ });
 }
-function newInterface(schema, rootSchema, processed, keyName, keyNameFromDefinition) {
+/**
+ * Compute a schema name using a series of fallbacks
+ */
+function standaloneName(schema, keyNameFromDefinition, usedNames) {
+    var name = schema.title || schema.id || keyNameFromDefinition;
+    if (name) {
+        return utils_1.generateName(name, usedNames);
+    }
+}
+function newInterface(schema, rootSchema, processed, usedNames, keyName, keyNameFromDefinition) {
     return {
         comment: schema.description,
         keyName: keyName,
-        params: parseSchema(schema, rootSchema, processed),
-        standaloneName: computeSchemaName(schema) || keyNameFromDefinition,
-        superTypes: parseSuperTypes(schema, processed),
+        params: parseSchema(schema, rootSchema, processed, usedNames),
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
+        superTypes: parseSuperTypes(schema, processed, usedNames),
         type: 'INTERFACE'
     };
 }
-function parseSuperTypes(schema, processed) {
+function parseSuperTypes(schema, processed, usedNames) {
     // Type assertion needed because of dereferencing step
@@ -213,8 +223,8 @@ // TODO: Type it upstream
     if (Array.isArray(superTypes)) {
-        return superTypes.map(function (_) { return newNamedInterface(_, _, processed); });
+        return superTypes.map(function (_) { return newNamedInterface(_, _, processed, usedNames); });
     }
-    return [newNamedInterface(superTypes, superTypes, processed)];
+    return [newNamedInterface(superTypes, superTypes, processed, usedNames)];
 }
-function newNamedInterface(schema, rootSchema, processed) {
-    var namedInterface = newInterface(schema, rootSchema, processed);
+function newNamedInterface(schema, rootSchema, processed, usedNames) {
+    var namedInterface = newInterface(schema, rootSchema, processed, usedNames);
     if (AST_1.hasStandaloneName(namedInterface)) {
@@ -227,13 +237,7 @@ return namedInterface;
 /**
- * Compute a schema name using a series of fallbacks
- */
-function computeSchemaName(schema) {
-    return schema.title || schema.id;
-}
-/**
  * Helper to parse schema properties into params on the parent schema's type
  */
-function parseSchema(schema, rootSchema, processed) {
+function parseSchema(schema, rootSchema, processed, usedNames) {
     var asts = lodash_1.map(schema.properties, function (value, key) { return ({
-        ast: parse(value, rootSchema, key, true, processed),
+        ast: parse(value, rootSchema, key, true, processed, usedNames),
         isRequired: lodash_1.includes(schema.required || [], key),
@@ -257,3 +261,3 @@ keyName: key
             return asts.concat({
-                ast: parse(schema.additionalProperties, rootSchema, '[k: string]', true, processed),
+                ast: parse(schema.additionalProperties, rootSchema, '[k: string]', true, processed, usedNames),
                 isRequired: true,
@@ -260,0 +264,0 @@ keyName: '[k: string]'

dist/src/utils.d.ts

@@ -24,3 +24,4 @@ export declare function Try<T>(fn: () => T, err: (e: Error) => any): T;
 export declare function toSafeString(string: string): string;
+export declare function generateName(from: string, usedNames: Set<string>): string;
 export declare function error(...messages: any[]): void;
 export declare function log(...messages: any[]): void;

dist/src/utils.js

@@ -60,2 +60,16 @@ "use strict";
 exports.toSafeString = toSafeString;
+function generateName(from, usedNames) {
+    var name = toSafeString(from);
+    // increment counter until we find a free name
+    if (usedNames.has(name)) {
+        var counter = 1;
+        while (usedNames.has(name)) {
+            name = "" + toSafeString(from) + counter;
+            counter++;
+        }
+    }
+    usedNames.add(name);
+    return name;
+}
+exports.generateName = generateName;
 function error() {
@@ -62,0 +76,0 @@ var messages = [];

package.json

 {
   "name": "json-schema-to-typescript",
-  "version": "4.6.4",
+  "version": "4.6.5",
   "description": "compile json schema to typescript typings",
@@ -5,0 +5,0 @@ "main": "dist/src/index.js",

src/parser.ts

@@ -7,6 +7,8 @@ import { whiteBright } from 'cli-color'
 import { JSONSchema, JSONSchemaWithDefinitions, SchemaSchema } from './types/JSONSchema'
-import { error, log } from './utils'
+import { error, generateName, log } from './utils'
 
 export type Processed = Map<JSONSchema | JSONSchema4Type, AST>
 
+export type UsedNames = Set<string>
+
 export function parse(
@@ -17,3 +19,4 @@ schema: JSONSchema | JSONSchema4Type,
   isSchema = true,
-  processed: Processed = new Map<JSONSchema | JSONSchema4Type, AST>()
+  processed: Processed = new Map<JSONSchema | JSONSchema4Type, AST>(),
+  usedNames = new Set<string>()
 ): AST {
@@ -37,3 +40,3 @@
   return isSchema
-    ? parseNonLiteral(schema as SchemaSchema, rootSchema, keyName, keyNameFromDefinition, set, processed)
+    ? parseNonLiteral(schema as SchemaSchema, rootSchema, keyName, keyNameFromDefinition, set, processed, usedNames)
     : parseLiteral(schema, keyName, keyNameFromDefinition, set)
@@ -62,3 +65,4 @@ }
   set: (ast: AST) => AST,
-  processed: Processed
+  processed: Processed,
+  usedNames: UsedNames
 ) {
@@ -73,4 +77,4 @@
         keyName,
-        params: schema.allOf!.map(_ => parse(_, rootSchema, undefined, true, processed)),
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        params: schema.allOf!.map(_ => parse(_, rootSchema, undefined, true, processed, usedNames)),
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'INTERSECTION'
@@ -82,3 +86,3 @@ })
         keyName,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'ANY'
@@ -90,4 +94,4 @@ })
         keyName,
-        params: schema.anyOf!.map(_ => parse(_, rootSchema, undefined, true, processed)),
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        params: schema.anyOf!.map(_ => parse(_, rootSchema, undefined, true, processed, usedNames)),
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'UNION'
@@ -99,3 +103,3 @@ })
         keyName,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'BOOLEAN'
@@ -108,10 +112,10 @@ })
         params: schema.enum!.map((_, n) => ({
-          ast: parse(_, rootSchema, undefined, false, processed),
+          ast: parse(_, rootSchema, undefined, false, processed, usedNames),
           keyName: schema.tsEnumNames![n]
         })),
-        standaloneName: schema.title || keyName!,
+        standaloneName: standaloneName(schema, keyName, usedNames)!,
         type: 'ENUM'
       })
     case 'NAMED_SCHEMA':
-      return set(newInterface(schema as SchemaSchema, rootSchema, processed, keyName))
+      return set(newInterface(schema as SchemaSchema, rootSchema, processed, usedNames, keyName))
     case 'NULL':
@@ -121,3 +125,3 @@ return set({
         keyName,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'NULL'
@@ -129,3 +133,3 @@ })
         keyName,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'NUMBER'
@@ -137,3 +141,3 @@ })
         keyName,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'OBJECT'
@@ -145,4 +149,4 @@ })
         keyName,
-        params: schema.oneOf!.map(_ => parse(_, rootSchema, undefined, true, processed)),
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        params: schema.oneOf!.map(_ => parse(_, rootSchema, undefined, true, processed, usedNames)),
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'UNION'
@@ -156,3 +160,3 @@ })
         keyName,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'STRING'
@@ -165,4 +169,4 @@ })
           keyName,
-          params: schema.items.map(_ => parse(_, rootSchema, undefined, true, processed)),
-          standaloneName: schema.title || schema.id || keyNameFromDefinition,
+          params: schema.items.map(_ => parse(_, rootSchema, undefined, true, processed, usedNames)),
+          standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
           type: 'TUPLE'
@@ -174,4 +178,4 @@ })
           keyName,
-          params: parse(schema.items!, rootSchema, undefined, true, processed),
-          standaloneName: schema.title || schema.id || keyNameFromDefinition,
+          params: parse(schema.items!, rootSchema, undefined, true, processed, usedNames),
+          standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
           type: 'ARRAY'
@@ -184,4 +188,4 @@ })
         keyName,
-        params: (schema.type as JSONSchema4TypeName[]).map(_ => parse({ type: _ }, rootSchema, undefined, true, processed)),
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        params: (schema.type as JSONSchema4TypeName[]).map(_ => parse({ type: _ }, rootSchema, undefined, true, processed, usedNames)),
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'UNION'
@@ -193,8 +197,8 @@ })
         keyName,
-        params: schema.enum!.map(_ => parse(_, rootSchema, undefined, false, processed)),
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        params: schema.enum!.map(_ => parse(_, rootSchema, undefined, false, processed, usedNames)),
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'UNION'
       })
     case 'UNNAMED_SCHEMA':
-      return set(newInterface(schema as SchemaSchema, rootSchema, processed, keyName, keyNameFromDefinition))
+      return set(newInterface(schema as SchemaSchema, rootSchema, processed, usedNames, keyName, keyNameFromDefinition))
     case 'UNTYPED_ARRAY':
@@ -205,3 +209,3 @@ return set({
         params: T_ANY,
-        standaloneName: schema.title || schema.id || keyNameFromDefinition,
+        standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
         type: 'ARRAY'
@@ -212,2 +216,16 @@ })
 
+/**
+ * Compute a schema name using a series of fallbacks
+ */
+function standaloneName(
+  schema: JSONSchema,
+  keyNameFromDefinition: string | undefined,
+  usedNames: UsedNames
+) {
+  let name = schema.title || schema.id || keyNameFromDefinition
+  if (name) {
+    return generateName(name, usedNames)
+  }
+}
+
 function newInterface(
@@ -217,2 +235,3 @@ schema: SchemaSchema,
   processed: Processed,
+  usedNames: UsedNames,
   keyName?: string,
@@ -224,5 +243,5 @@ keyNameFromDefinition?: string
     keyName,
-    params: parseSchema(schema, rootSchema, processed),
-    standaloneName: computeSchemaName(schema) || keyNameFromDefinition,
-    superTypes: parseSuperTypes(schema, processed),
+    params: parseSchema(schema, rootSchema, processed, usedNames),
+    standaloneName: standaloneName(schema, keyNameFromDefinition, usedNames),
+    superTypes: parseSuperTypes(schema, processed, usedNames),
     type: 'INTERFACE'
@@ -234,3 +253,4 @@ }
   schema: SchemaSchema,
-  processed: Processed
+  processed: Processed,
+  usedNames: UsedNames
 ): TNamedInterface[] {
@@ -244,5 +264,5 @@ // Type assertion needed because of dereferencing step
   if (Array.isArray(superTypes)) {
-    return superTypes.map(_ => newNamedInterface(_, _, processed))
+    return superTypes.map(_ => newNamedInterface(_, _, processed, usedNames))
   }
-  return [newNamedInterface(superTypes, superTypes, processed)]
+  return [newNamedInterface(superTypes, superTypes, processed, usedNames)]
 }
@@ -253,5 +273,6 @@
   rootSchema: JSONSchema,
-  processed: Processed
+  processed: Processed,
+  usedNames: UsedNames
 ): TNamedInterface {
-  const namedInterface = newInterface(schema, rootSchema, processed)
+  const namedInterface = newInterface(schema, rootSchema, processed, usedNames)
   if (hasStandaloneName(namedInterface)) {
@@ -265,9 +286,2 @@ return namedInterface
 /**
- * Compute a schema name using a series of fallbacks
- */
-function computeSchemaName(schema: SchemaSchema): string | undefined {
-  return schema.title || schema.id
-}
-
-/**
  * Helper to parse schema properties into params on the parent schema's type
@@ -278,7 +292,8 @@ */
   rootSchema: JSONSchema,
-  processed: Processed
+  processed: Processed,
+  usedNames: UsedNames
 ): TInterfaceParam[] {
 
   const asts = map(schema.properties, (value, key: string) => ({
-    ast: parse(value, rootSchema, key, true, processed),
+    ast: parse(value, rootSchema, key, true, processed, usedNames),
     isRequired: includes(schema.required || [], key),
@@ -305,3 +320,3 @@ keyName: key
       return asts.concat({
-        ast: parse(schema.additionalProperties, rootSchema, '[k: string]', true, processed),
+        ast: parse(schema.additionalProperties, rootSchema, '[k: string]', true, processed, usedNames),
         isRequired: true,
@@ -308,0 +323,0 @@ keyName: '[k: string]'

src/utils.ts

@@ -59,2 +59,18 @@ import { whiteBright } from 'cli-color'
 
+export function generateName(from: string, usedNames: Set<string>) {
+  let name = toSafeString(from)
+
+  // increment counter until we find a free name
+  if (usedNames.has(name)) {
+    let counter = 1
+    while (usedNames.has(name)) {
+      name = `${toSafeString(from)}${counter}`
+      counter++
+    }
+  }
+
+  usedNames.add(name)
+  return name
+}
+
 export function error(...messages: any[]) {
@@ -61,0 +77,0 @@ console.error(whiteBright.bgRedBright('error'), ...messages)

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

1418965

increased by0.22%

Lines of code

36955

increased by0.18%

No dependency changes