@jmm-devkit/ngx-form-generator 1.2.1 → 1.2.2

package/dist/generator-lib.d.ts

@@ -7,9 +7,38 @@
  */
 import { Rule } from './rules';
 import { OpenAPI } from 'openapi-types';
+/**
+ * Generates Angular ReactiveForms from an OpenAPI v2 or v3 spec.
+ * @param spec - The OpenAPI document.
+ * @returns A string representing the generated forms.
+ */
+export declare function makeForm(spec: OpenAPI.Document): string;
+/**
+ * Adds a validation rule for a form field.
+ * @param rule - The validation rule to add.
+ */
 export declare function addRule(rule: Rule): void;
+/**
+ * Removes a validation rule from the form field rules.
+ * @param rule - The validation rule to remove.
+ */
 export declare function resetRules(): void;
+/**
+ * Generates a file name based on the OpenAPI spec title.
+ * @param swagger - The OpenAPI document.
+ * @returns A string representing the file name or undefined if no title is available.
+ */
 export declare function makeFileName(swagger: OpenAPI.Document): string | undefined;
-export declare function makeForm(spec: OpenAPI.Document): string;
+/**
+ * Saves the generated file using ts-morph.
+ * @param file - The content of the file to save.
+ * @param fileName - The name of the file to save.
+ * @returns A promise that resolves when the file is saved.
+ */
 export declare function saveFile(file: string, fileName: string): Promise<void>;
+/**
+ * Loads an OpenAPI specification from a file or URL.
+ * @param fileOrUrlPath - The path to the OpenAPI spec file or URL.
+ * @returns A promise that resolves to the dereferenced OpenAPI document.
+ */
 export declare function loadSpec(fileOrUrlPath: string): Promise<OpenAPI.Document>;

package/dist/generator-lib.js

@@ -10,91 +10,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadSpec = exports.saveFile = exports.makeForm = exports.makeFileName = exports.resetRules = exports.addRule = void 0;
+exports.loadSpec = exports.saveFile = exports.makeFileName = exports.resetRules = exports.addRule = exports.makeForm = void 0;
 const ts_morph_1 = require("ts-morph");
 const prettier_1 = __importDefault(require("prettier"));
 const camelcase_1 = __importDefault(require("camelcase"));
 const rules_1 = require("./rules");
 const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
 const DEFAULT_RULES = [rules_1.requiredRule, rules_1.patternRule, rules_1.minLengthRule, rules_1.maxLengthRule, rules_1.emailRule, rules_1.minimumRule, rules_1.maximumRule];
+const NEEDED_IMPORTS = `import { FormGroup, FormControl, Validators, FormArray } from '@angular/forms'; \n`;
 let rules = [...DEFAULT_RULES];
-function addRule(rule) {
-    rules.push(rule);
-}
-exports.addRule = addRule;
-function resetRules() {
-    rules = [...DEFAULT_RULES];
-}
-exports.resetRules = resetRules;
-function makeFileName(swagger) {
-    if (swagger.info && swagger.info.title) {
-        return `${(0, camelcase_1.default)(swagger.info.title)}.ts`;
-    }
-}
-exports.makeFileName = makeFileName;
-function makeFieldRules(fieldName, definition) {
-    return rules
-        .map(rule => rule(fieldName, definition))
-        .filter(item => item != '')
-        .join();
-}
-function makeField(fieldName, definition) {
-    if (definition.properties[fieldName]['type'] === 'array') {
-        const itemDefinition = definition.properties[fieldName]['items'];
-        const minItems = +definition.properties[fieldName]['minItems'] || 1;
-        const items = [];
-        if (itemDefinition['type'] === 'object') {
-            for (let i = 0; i <= minItems; i++) {
-                items.push(`new FormGroup({${makeFieldsBody(itemDefinition)}})`);
-            }
-        }
-        else {
-            const _dummyProps = {
-                properties: {
-                    dummy: itemDefinition
-                }
-            };
-            const value = 'default' in _dummyProps.properties.dummy ? `'${_dummyProps.properties.dummy.default}'` : null;
-            for (let i = 1; i <= minItems; i++) {
-                items.push(`new FormControl(${value}, [${makeFieldRules('dummy', _dummyProps)}])`);
-            }
-        }
-        return `"${fieldName}": new FormArray([${items.join(',')}])`;
-    }
-    else if (definition.properties[fieldName]['type'] === 'object') {
-        const constructFormGroup = makeFieldsBody(definition.properties[fieldName]);
-        return `"${fieldName}": new FormGroup({${constructFormGroup}})`;
-    }
-    const value = 'default' in definition.properties[fieldName] ? `'${definition.properties[fieldName].default}'` : null;
-    return `"${fieldName}": new FormControl(${value}, [${makeFieldRules(fieldName, definition)}])`;
-}
-function makeFieldsBody(definition) {
-    if ('allOf' in definition) {
-        const definitionKeys = Object.keys(definition.allOf);
-        const allOfFieldsBody = definitionKeys
-            .map(key => makeFieldsBody(definition.allOf[key]))
-            .reduce((acc, val) => acc.concat(val), []);
-        return allOfFieldsBody;
-    }
-    if (!definition.properties)
-        return [];
-    const fields = Object.keys(definition.properties);
-    const fieldsBody = fields.map(fieldName => makeField(fieldName, definition)).filter(item => item !== '');
-    return fieldsBody;
-}
-function makeDefinition(definitionName, definition) {
-    const fieldsBody = makeFieldsBody(definition);
-    return `
-    export const ${(0, camelcase_1.default)(definitionName)}Form = () => new FormGroup({
-      ${fieldsBody}
-    });
-    `;
-}
-function makeHeader(body) {
-    return `import { FormGroup, FormControl, Validators, FormArray } from '@angular/forms';
-
-  ${body}`;
-}
+/**
+ * Generates Angular ReactiveForms from an OpenAPI v2 or v3 spec.
+ * @param spec - The OpenAPI document.
+ * @returns A string representing the generated forms.
+ */
 function makeForm(spec) {
     var _a;
     let definitions;
@@ -110,21 +39,182 @@ function makeForm(spec) {
     if (!definitions) {
         throw new Error('Cannot find schemas/definitions');
     }
-    const definitionKeys = Object.keys(definitions);
-    const forms = definitionKeys
-        .map(key => makeDefinition(key, definitions[key]))
-        .filter(item => item != '')
-        .join('');
-    const file = makeHeader(forms);
-    return prettier_1.default.format(file, { parser: 'typescript', singleQuote: true });
+    let body = NEEDED_IMPORTS + '\n\n';
+    Object.keys(definitions).forEach(key => {
+        if (definitions === null || definitions === void 0 ? void 0 : definitions[key]) {
+            body += makeDefinition(key, definitions[key]);
+        }
+    });
+    return prettier_1.default.format(body, { parser: 'typescript', singleQuote: true });
 }
 exports.makeForm = makeForm;
+/**
+ * Creates a form definition for a given OpenAPI definition.
+ * @param definitionName - The name of the definition.
+ * @param definition - The OpenAPI definition object.
+ * @returns A string representing the form definition.
+ */
+function makeDefinition(definitionName, definition) {
+    return `export const ${(0, camelcase_1.default)(definitionName)}Form = () => new FormGroup({
+      ${makeFieldsBody(definition, 0)}
+    });\n`;
+}
+/**
+ * Generates the body of fields for a form based on the provided definition.
+ * @param definition - The OpenAPI definition object containing properties.
+ * @param depth - The current depth of recursion.
+ * @returns An array of strings representing the form fields.
+ */
+function makeFieldsBody(definition, depth) {
+    if (!('properties' in definition) || !definition.properties || depth > 2)
+        return [];
+    depth++;
+    const fields = [];
+    Object.keys(definition.properties).forEach(fieldName => {
+        var _a, _b;
+        const field = makeField(fieldName, (_a = definition.properties) === null || _a === void 0 ? void 0 : _a[fieldName], !!((_b = definition.required) === null || _b === void 0 ? void 0 : _b.includes(fieldName)), depth);
+        if (field !== '') {
+            fields.push(field);
+        }
+    });
+    return fields;
+}
+/**
+ * Creates a form field for a given OpenAPI property.
+ * @param fieldName - The name of the field.
+ * @param property - The OpenAPI property object.
+ * @param isRequired - Indicates if the field is required.
+ * @param depth - The current depth of recursion.
+ * @returns A string representing the form field.
+ */
+function makeField(fieldName, property, isRequired, depth) {
+    let fieldRepesentation;
+    if (property.allOf) {
+        fieldRepesentation = makeField(fieldName, property.allOf, isRequired, depth);
+    }
+    else if (property.type === 'array') {
+        fieldRepesentation = makeArrayField(fieldName, property, isRequired, depth);
+    }
+    else if (property.type === 'object') {
+        fieldRepesentation = makeObjectField(fieldName, property, isRequired, depth);
+    }
+    else {
+        fieldRepesentation = makePrimitiveField(fieldName, property, isRequired);
+    }
+    return fieldRepesentation;
+}
+/**
+ * Creates a form array field for a given OpenAPI array schema.
+ * @param fieldName - The name of the field.
+ * @param property - The OpenAPI array schema object.
+ * @param isRequired - Indicates if the field is required.
+ * @param depth - The current depth of recursion.
+ * @returns A string representing the form array field.
+ */
+function makeArrayField(fieldName, property, isRequired, depth) {
+    var _a;
+    const itemDefinition = property.items;
+    const minItems = (_a = property['minItems']) !== null && _a !== void 0 ? _a : 1;
+    const items = [];
+    if (itemDefinition['type'] === 'object') {
+        for (let i = 0; i <= minItems; i++) {
+            items.push(`new FormGroup({${makeFieldsBody(itemDefinition, depth)}})`);
+        }
+    }
+    else {
+        const _dummyProps = {
+            properties: {
+                dummy: itemDefinition
+            }
+        };
+        const value = 'default' in _dummyProps.properties.dummy ? `'${_dummyProps.properties.dummy.default}'` : null;
+        for (let i = 1; i <= minItems; i++) {
+            items.push(`new FormControl(${value}, [${makeFieldRules('dummy', _dummyProps, isRequired)}])`);
+        }
+    }
+    return `"${fieldName}": new FormArray([${items.join(',')}])`;
+}
+/**
+ * Creates a form object field for a given OpenAPI object schema.
+ * @param fieldName - The name of the field.
+ * @param property - The OpenAPI object schema object.
+ * @param isRequired - Indicates if the field is required.
+ * @param depth - The current depth of recursion.
+ * @returns A string representing the form object field.
+ */
+function makeObjectField(fieldName, property, isRequired, depth) {
+    const groupBody = makeFieldsBody(property, depth);
+    return `"${fieldName}": new FormGroup({${groupBody}}, [${makeFieldRules(fieldName, property, isRequired)}])`;
+}
+/**
+ * Creates a form control for a primitive field based on its OpenAPI definition.
+ * @param fieldName - The name of the field.
+ * @param property - The OpenAPI property object.
+ * @param isRequired - Indicates if the field is required.
+ * @returns A string representing the form control.
+ */
+function makePrimitiveField(fieldName, property, isRequired) {
+    const value = 'default' in property ? `'${property.default}'` : null;
+    return `"${fieldName}": new FormControl(${value}, [${makeFieldRules(fieldName, property, isRequired)}])`;
+}
+/**
+ * Creates validation rules for a form field based on its OpenAPI definition.
+ * @param fieldName - The name of the field.
+ * @param property - The OpenAPI property object.
+ * @param isRequired - Indicates if the field is required.
+ * @returns A string representing the validation rules.
+ */
+function makeFieldRules(fieldName, property, isRequired) {
+    return rules
+        .map(rule => rule(fieldName, property, isRequired))
+        .filter(item => item != '')
+        .join();
+}
+/**
+ * Adds a validation rule for a form field.
+ * @param rule - The validation rule to add.
+ */
+function addRule(rule) {
+    rules.push(rule);
+}
+exports.addRule = addRule;
+/**
+ * Removes a validation rule from the form field rules.
+ * @param rule - The validation rule to remove.
+ */
+function resetRules() {
+    rules = [...DEFAULT_RULES];
+}
+exports.resetRules = resetRules;
+/**
+ * Generates a file name based on the OpenAPI spec title.
+ * @param swagger - The OpenAPI document.
+ * @returns A string representing the file name or undefined if no title is available.
+ */
+function makeFileName(swagger) {
+    var _a;
+    if ((_a = swagger.info) === null || _a === void 0 ? void 0 : _a.title) {
+        return `${(0, camelcase_1.default)(swagger.info.title)}.ts`;
+    }
+}
+exports.makeFileName = makeFileName;
+/**
+ * Saves the generated file using ts-morph.
+ * @param file - The content of the file to save.
+ * @param fileName - The name of the file to save.
+ * @returns A promise that resolves when the file is saved.
+ */
 async function saveFile(file, fileName) {
     const project = new ts_morph_1.Project();
     project.createSourceFile(fileName, file, { overwrite: true });
     return project.save();
 }
 exports.saveFile = saveFile;
+/**
+ * Loads an OpenAPI specification from a file or URL.
+ * @param fileOrUrlPath - The path to the OpenAPI spec file or URL.
+ * @returns A promise that resolves to the dereferenced OpenAPI document.
+ */
 async function loadSpec(fileOrUrlPath) {
     const parser = new swagger_parser_1.default();
     return parser.dereference(fileOrUrlPath);

package/dist/rules.d.ts

@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2020 Verizon
  */
-import { OpenAPIV2 } from 'openapi-types';
+import { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
 export declare type Property = {
     format?: string;
     pattern?: string;
@@ -15,12 +15,14 @@ export declare type Property = {
     maximum?: number;
 };
 export declare type Properties = Record<string, Property>;
-export declare type Rule = (fieldName: string, properties: Definition) => string;
-export declare type Definition = OpenAPIV2.DefinitionsObject;
-export declare function requiredRule(fieldName: string, definition: Definition): string;
-export declare function patternRule(fieldName: string, definition: Definition): string;
-export declare function minLengthRule(fieldName: string, definition: Definition): string;
-export declare function maxLengthRule(fieldName: string, definition: Definition): string;
-export declare function emailRule(fieldName: string, definition: Definition): string;
-export declare function minimumRule(fieldName: string, definition: Definition): string;
-export declare function maximumRule(fieldName: string, definition: Definition): string;
+export declare type Rule = (fieldName: string, properties: SchemaProperty, isRequired: boolean) => string;
+export declare type Definitions = OpenAPIV2.DefinitionsObject | Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject> | undefined;
+export declare type Definition = OpenAPIV2.DefinitionsObject | OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+export declare type SchemaProperty = OpenAPIV2.SchemaObject | OpenAPIV3.SchemaObject;
+export declare function requiredRule(fieldName: string, property: SchemaProperty, isRequired: boolean): string;
+export declare function patternRule(fieldName: string, property: SchemaProperty): string;
+export declare function minLengthRule(fieldName: string, property: SchemaProperty): string;
+export declare function maxLengthRule(fieldName: string, property: SchemaProperty): string;
+export declare function emailRule(fieldName: string, property: SchemaProperty): string;
+export declare function minimumRule(fieldName: string, property: SchemaProperty): string;
+export declare function maximumRule(fieldName: string, property: SchemaProperty): string;

package/dist/rules.js

@@ -8,45 +8,37 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maximumRule = exports.minimumRule = exports.emailRule = exports.maxLengthRule = exports.minLengthRule = exports.patternRule = exports.requiredRule = void 0;
-function hasMetadata(fieldName, definition, metadataName) {
-    return definition.properties[fieldName].hasOwnProperty(metadataName);
+function hasMetadata(fieldName, property, metadataName) {
+    return property.hasOwnProperty(metadataName);
 }
-function abstractRule(fieldName, definition, ruleName) {
-    return hasMetadata(fieldName, definition, ruleName)
-        ? `Validators.${ruleName}(${definition.properties[fieldName][ruleName]})`
-        : '';
+function abstractRule(fieldName, property, ruleName) {
+    return hasMetadata(fieldName, property, ruleName) ? `Validators.${ruleName}(${property[ruleName]})` : '';
 }
-function requiredRule(fieldName, definition) {
-    return definition.required && definition.required.includes(fieldName) ? `Validators.required` : '';
+function requiredRule(fieldName, property, isRequired) {
+    return isRequired ? `Validators.required` : '';
 }
 exports.requiredRule = requiredRule;
-function patternRule(fieldName, definition) {
-    return hasMetadata(fieldName, definition, 'pattern')
-        ? `Validators.pattern(/${definition.properties[fieldName]['pattern']}/)`
-        : '';
+function patternRule(fieldName, property) {
+    return hasMetadata(fieldName, property, 'pattern') ? `Validators.pattern(/${property['pattern']}/)` : '';
 }
 exports.patternRule = patternRule;
-function minLengthRule(fieldName, definition) {
-    return abstractRule(fieldName, definition, 'minLength');
+function minLengthRule(fieldName, property) {
+    return abstractRule(fieldName, property, 'minLength');
 }
 exports.minLengthRule = minLengthRule;
-function maxLengthRule(fieldName, definition) {
-    return abstractRule(fieldName, definition, 'maxLength');
+function maxLengthRule(fieldName, property) {
+    return abstractRule(fieldName, property, 'maxLength');
 }
 exports.maxLengthRule = maxLengthRule;
-function emailRule(fieldName, definition) {
-    return definition.properties[fieldName].format === 'email' ? `Validators.email` : '';
+function emailRule(fieldName, property) {
+    return property.format === 'email' ? `Validators.email` : '';
 }
 exports.emailRule = emailRule;
-function minimumRule(fieldName, definition) {
-    return hasMetadata(fieldName, definition, 'minimum')
-        ? `Validators.min(${definition.properties[fieldName]['minimum']})`
-        : '';
+function minimumRule(fieldName, property) {
+    return hasMetadata(fieldName, property, 'minimum') ? `Validators.min(${property['minimum']})` : '';
 }
 exports.minimumRule = minimumRule;
-function maximumRule(fieldName, definition) {
-    return hasMetadata(fieldName, definition, 'maximum')
-        ? `Validators.max(${definition.properties[fieldName]['maximum']})`
-        : '';
+function maximumRule(fieldName, property) {
+    return hasMetadata(fieldName, property, 'maximum') ? `Validators.max(${property['maximum']})` : '';
 }
 exports.maximumRule = maximumRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmm-devkit/ngx-form-generator",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Generates an Angular ReactiveForm from a Swagger or OpenAPI definition",
   "main": "dist/generator-lib.js",
   "repository": "github:jmm-devkit/ngx-form-generator",