fix(guards): circular dependency

all guard functions defined in the exported index file

Author: vmasek

src/generator.ts

@@ -198,59 +198,26 @@ async function generateModelGuards(
 ): Promise<string[]> {
   const outputDir = join(outputPath, MODEL_GUARDS_DIR_NAME);
   const outIndexFile = join(outputDir, '/index.ts');
-  const outHelpersFile = join(outputDir, '/build-in.guards.ts');
-
-  const modelGuardTemplate = (
-    await promisify(readFile)(
-      `${__dirname}/../templates/ngx-model-guard.mustache`,
-    )
-  ).toString();
 
   const modelGuardsExportTemplate = (
     await promisify(readFile)(
       `${__dirname}/../templates/ngx-model-guards-export.mustache`,
     )
   ).toString();
 
-  const modelGuardsHelpersTemplate = (
-    await promisify(readFile)(
-      `${__dirname}/../templates/ngx-model-guards-helpers.mustache`,
-    )
-  ).toString();
-
   if (!existsSync(outputDir)) {
     await promisify(mkdir)(outputDir);
   }
 
-  // generate model guards export index for all the generated models
+  // generate model guards export index with all the generated guards
   await promisify(writeFile)(
     outIndexFile,
     Mustache.render(modelGuardsExportTemplate, { definitions }),
     'utf-8',
   );
 
-  // generate model guards pre prepared helper guards (for string, number, File, Blob, ...)
-  await promisify(writeFile)(
-    outHelpersFile,
-    Mustache.render(modelGuardsHelpersTemplate, {}),
-    'utf-8',
-  );
-
   // generate API models
-  return Promise.all([
-    ...definitions.map(async definition => {
-      const result = Mustache.render(modelGuardTemplate, definition);
-      const outfile = join(
-        outputDir,
-        `${fileName(definition.definitionName, 'guard')}.ts`,
-      );
-
-      await ensureDir(dirname(outfile));
-      await promisify(writeFile)(outfile, result, 'utf-8');
-      return outfile;
-    }),
-    outIndexFile,
-  ]);
+  return [outIndexFile];
 }
 
 async function generateModuleExportIndex(

src/helper.ts

@@ -3,7 +3,6 @@ import { FileInfix } from './types';
 
 export const BASIC_TS_TYPE_REGEX = /\b(?:string|number|integer|boolean|void)\b/;
 const BUILD_IN_TS_TYPE_REGEX = /^(?:string|number|integer|boolean|null|undefined|any|void|Object|File|Blob)\b/i;
-export const BUILD_GUARD_HELPERS_REGEX = /is(string|number|integer|boolean|any|Object|File|Blob)\(/gm;
 
 export const ADDITIONAL_PROPERTIES_KEY = '[key: string]';
 

src/parser.ts

@@ -30,7 +30,6 @@ import {
   compareStringByKey,
   isReference,
   ADDITIONAL_PROPERTIES_KEY,
-  BUILD_GUARD_HELPERS_REGEX,
 } from './helper';
 
 interface Parameters {
@@ -90,8 +89,8 @@ export function createMustacheViewModel(
 }
 
 export function determineDomain({ schemes, host, basePath }: Swagger): string {
-  // if the host is defined then try and use a protocol from the swagger file
-  // otherwise use the current protocol of loaded app
+  // if the host definition exists then try to use a protocol from the swagger file
+  // otherwise, use the current protocol of loaded app
   const protocol =
     host && schemes && schemes.length > 0 ? `${schemes[0]}://` : '//';
 
@@ -125,7 +124,7 @@ function parseMethods(
           return (
             supportedMethods.indexOf(methodType.toUpperCase()) !== -1 && // skip unsupported methods
             (!swaggerTag || (op.tags && op.tags.includes(swaggerTag)))
-          ); // if tag is defined take only paths including this tag
+          ); // if tag exists take only paths including this tag
         })
         .map(([methodType, operation]: [string, Operation]) => {
           // select the lowest success (code 20x) response
@@ -230,7 +229,7 @@ function parseDefinitions(
                   ({ definitionName }) =>
                     definitionName === prop.typescriptType,
                 )
-                  ? a // do not parse if type def is already in parsed definitions
+                  ? a // do not parse if type def already exists in parsed definitions
                   : [...a, ...filterByName(prop.typescriptType!, namedDefs)],
               [],
             ),
@@ -312,10 +311,6 @@ function defineEnum(
       text: string,
       render: Render,
     ): string => fileName(render(text), 'enum'),
-    renderFileNameGuard: (): RenderFileName => (
-      text: string,
-      render: Render,
-    ): string => fileName(render(text), 'guard'),
   };
 }
 
@@ -509,43 +504,17 @@ function defineInterface(schema: Schema, definitionKey: string): Definition {
     // filter duplicate imports
     .filter((el, i, a) => (i === a.indexOf(el) ? 1 : 0));
 
-  const modelGuardImports = modelImports.map(
-    el => `import { is${el} } from './${fileName(el, 'guard')}';`,
-  );
-
-  const helpersGuardImports = Array.prototype.concat
-    // tslint:disable-next-line:no-array-mutation
-    .apply(
-      [],
-      properties.map(
-        ({ guard = '' }) => guard.match(BUILD_GUARD_HELPERS_REGEX) || [],
-      ),
-    )
-    .sort()
-    .filter((guardHelper, index, self) =>
-      index > 0 ? guardHelper !== self[index - 1] : true,
-    )
-    .map(
-      guardHelper =>
-        `import { ${guardHelper.slice(0, -1)} } from './build-in.guards';`,
-    );
-
   return {
     definitionName: name,
     description: replaceNewLines(schema.description, '$1 * '),
     properties: properties,
     imports: modelImports,
-    guardImports: [...modelGuardImports, ...helpersGuardImports],
     isEnum: false,
     extend: extendInterface,
     renderFileName: (): RenderFileName => (
       text: string,
       render: Render,
     ): string => fileName(render(text), 'model'),
-    renderFileNameGuard: (): RenderFileName => (
-      text: string,
-      render: Render,
-    ): string => fileName(render(text), 'guard'),
   };
 }
 
@@ -692,7 +661,7 @@ function determineParamType(
     case 'query' || 'modelbinding':
       return { isQueryParameter: true };
     default:
-      logWarn(`Unsupported parameter type  [ ${paramType} ]`);
+      logWarn(`Unsupported parameter type [ ${paramType} ]`);
       return {};
   }
 }

src/types.ts

@@ -7,13 +7,11 @@ export interface Definition {
   readonly definitionName: string;
   readonly properties: Property[];
   readonly imports: string[];
-  readonly guardImports?: string[];
   readonly extend?: string;
   readonly description?: string;
   readonly isEnum?: boolean;
   readonly isNumeric?: boolean; // used for determining if string or numeric enum should be generated
   renderFileName(): RenderFileName; // generate dash-case file names to templates
-  renderFileNameGuard(): RenderFileName; // generate dash-case file names to templates
 }
 
 export interface MustacheData {
@@ -43,7 +41,7 @@ export type In =
   | 'header'
   | 'formData';
 export type MethodType = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export type FileInfix = 'model' | 'enum' | 'service' | 'interface' | 'guard';
+export type FileInfix = 'model' | 'enum' | 'service' | 'interface';
 
 export interface Property {
   readonly camelCaseName?: string;

templates/ngx-model-guard.mustache

@@ -1,8 +1,69 @@
 /* tslint:disable */
 
+import * as models from '../models';
+
+/* pre-prepared guards for build in complex types */
+
+export function isany(_: any): _ is any {
+  return true;
+}
+
+export function isstring(arg: any): arg is string {
+  return typeof arg === 'string';
+}
+
+export function isnumber(arg: any): arg is number {
+  return typeof arg === 'number';
+}
+
+export function isboolean(arg: any): arg is boolean {
+  return typeof arg === 'boolean';
+}
+
+export function isObject(arg: any): arg is any {
+  return typeof arg === 'object';
+}
+
+export function isBlob(arg: any): arg is Blob {
+  return arg != null && typeof arg.size === 'number' && typeof arg.type === 'string' && typeof arg.slice === 'function';
+}
+
+export function isFile(arg: any): arg is File {
+return arg != null && typeof arg.lastModified === 'number' && typeof arg.name === 'string' && isBlob(arg);
+}
+
+/* generated type guards */
+
 {{#definitions}}
-export { is{{definitionName}} } from './{{#renderFileNameGuard}}{{definitionName}}{{/renderFileNameGuard}}';
+{{^isEnum}}
+export function is{{&definitionName}}(arg: any): arg is models.{{&definitionName}} {
+  return (
+  arg != null &&
+  typeof arg === 'object' &&
+  {{#properties}}
+    // {{&name}}{{^isRequired}}?{{/isRequired}}: {{#isDictionary}}{ [key: string]: {{&typescriptType}} }{{/isDictionary}}{{^isDictionary}}{{&typescriptType}}{{/isDictionary}}{{#isArray}}[]{{/isArray}}
+    {{&guard}}
+  {{/properties}}
+  {{#extend}}
+    // extends {{&.}}
+    is{{&.}}(arg) &&
+  {{/extend}}
+
+  true
+  );
+  }
+
+{{/isEnum}}{{#isEnum}}
+  import {
+  {{&definitionName}},
+  } from '../models';
+
+  export function is{{&definitionName}}(arg: any): arg is {{&definitionName}} {
+  return false
+  {{#properties}} || arg === {{&definitionName}}.{{name}}
+  {{/properties}};
+  }
+
+{{/isEnum}}
 {{/definitions}}
 
-/* build in guard helpers */
-export * from './build-in.guards';