@jmm-devkit/ngx-form-generator 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2020 Verizon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,118 @@
+# Changes and Improvements over the Original
+
+## Fixes
+
+- Fixed the handling of the `properties` property when generating fields from the OpenAPI definition. Now, if `properties` is `undefined`, an empty array is returned, allowing the rest of the code to execute correctly.
+
+## Improvements
+
+- The form constant is now an arrow function. This allows the form to be reused without persisting its state between uses, as previously, being an object, the form state was retained.
+
+# Angular Form Generator
+
+Generates an Angular ReactiveForm from a Swagger or OpenAPI definition.
+
+Validation rules should have a single source of truth. These rules should be exposed to consumers to apply them. By doing this we can be sure that the same rules for UI validation are enforced at the API layer.
+
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+
+## Install
+
+```bash
+# install locally in project
+npm install @jmm-devkit/ngx-form-generator --save-dev
+
+# install globally
+npm install @jmm-devkit/ngx-form-generator -g
+```
+
+## CLI Usage
+
+```bash
+ngx-form-generator -f swagger.json -o projects/forms/src/lib/
+
+# when installed locally in project run with npx
+npx ngx-form-generator -f swagger.yaml -o projects/forms/src/lib/
+```
+
+| Option       | Alias            | Comment                                          | Required |
+| ------------ | ---------------- | ------------------------------------------------ | -------- |
+| --version    |                  | Show version number                              |          |
+| --input-spec | -i, --swaggerUrl | Location of the OpenAPI spec as URL or file path | ✓        |
+| --output     | -o, --outDir     | Where to write the generated files               |          |
+| --file-name  | -f, --outFile    | Generated file name                              |          |
+| --help       | -h               | Show help                                        |          |
+
+### Example CLI Usage
+
+```bash
+ngx-form-generator -i https://petstore.swagger.io/v2/swagger.json -o petstore-forms
+ngx-form-generator -i https://petstore.swagger.io/v2/swagger.yaml -o petstore-forms
+npx ngx-form-generator -i swagger.json -o project/form/src/lib
+```
+
+## Library Usage
+
+```typescript
+import { loadSpec, makeForm, saveFile } from '@verizonconnect/ngx-form-generator';
+
+async function main() {
+  const spec = await loadSpec('swagger.json');
+  const form = makeForm(spec);
+  await saveFile(form, 'projects/forms/src/lib/index.ts');
+}
+await main();
+```
+
+## Examples Generated Form
+
+```typescript
+import { FormGroup, FormControl, Validators } from '@angular/forms';
+
+export const addressModelForm = () => new FormGroup({
+  firstName: new FormControl(null, [
+    Validators.required,
+    Validators.pattern(/^[a-zA-Z\'\s]+$/),
+    Validators.minLength(1),
+    Validators.maxLength(100)
+  ]),
+  lastName: new FormControl(null, [
+    Validators.required,
+    Validators.pattern(/^[a-zA-Z\'\s]+$/),
+    Validators.minLength(1),
+    Validators.maxLength(100)
+  ]),
+  address: new FormControl(null, [
+    Validators.required,
+    Validators.pattern(/^[\w\'\s]+$/),
+    Validators.minLength(1),
+    Validators.maxLength(100)
+  ]),
+  address2: new FormControl(null, [
+    Validators.pattern(/^[\w\'\s]+$/),
+    Validators.minLength(1),
+    Validators.maxLength(100)
+  ]),
+  city: new FormControl(null, [
+    Validators.required,
+    Validators.pattern(/^[\w\'\s]+$/),
+    Validators.minLength(1),
+    Validators.maxLength(100)
+  ]),
+  postalCode: new FormControl(null, [
+    Validators.required,
+    Validators.pattern(/^[\w\s]+$/),
+    Validators.minLength(4),
+    Validators.maxLength(8)
+  ]),
+  emailAddress: new FormControl(null, [
+    Validators.required,
+    Validators.pattern(/^[\w\@\!\#\%\&\'\*\+\-\/\=\?\`\{\|\}\~\.]+$/),
+    Validators.email
+  ])
+});
+```
+
+## License
+
+[MIT](./LICENSE)

package/dist/generator-cli.js

@@ -0,0 +1,47 @@
+#! /usr/bin/env node
+"use strict";
+/**
+ * @license
+ * Licensed under the MIT License, (“the License”); you may not use this
+ * file except in compliance with the License.
+ *
+ * Copyright (c) 2020 Verizon
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_lib_1 = require("./generator-lib");
+const path_1 = require("path");
+const yargs = require('yargs');
+async function main() {
+    const argv = yargs
+        .option('input-spec', {
+        alias: ['i', 'swaggerUrl'],
+        description: 'Location of the OpenAPI spec as a URL or file path',
+        type: 'string',
+        require: true
+    })
+        .option('output', {
+        alias: ['o', 'outDir'],
+        description: 'Where to write the generated files',
+        type: 'string'
+    })
+        .option('file-name', {
+        alias: ['f', 'outFile'],
+        description: 'Generated file name',
+        type: 'string'
+    })
+        .help()
+        .wrap(null)
+        .usage('Generates Angular ReactiveForms from an OpenAPI v2 or v3 spec.\n\n Usage: $0 -i <spec> -o <path>')
+        .example('ngx-form-generator -i https://petstore.swagger.io/v2/swagger.json -o petstore-forms')
+        .example('ngx-form-generator -i https://petstore.swagger.io/v2/swagger.yaml -o petstore-forms')
+        .example('npx ngx-form-generator -i swagger.json -o project/form/src/lib')
+        .alias('help', 'h').argv;
+    const spec = await (0, generator_lib_1.loadSpec)(argv['input-spec']);
+    const file = (0, generator_lib_1.makeForm)(spec);
+    let fileName = argv['file-name'] || (0, generator_lib_1.makeFileName)(spec) || 'forms.ts';
+    if (argv.output) {
+        fileName = (0, path_1.join)(argv.output, fileName);
+    }
+    await (0, generator_lib_1.saveFile)(file, fileName);
+}
+main();

package/dist/generator-lib.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Licensed under the MIT License, (“the License”); you may not use this
+ * file except in compliance with the License.
+ *
+ * Copyright (c) 2020 Verizon
+ */
+import { Rule } from './rules';
+import { OpenAPI } from 'openapi-types';
+export declare function addRule(rule: Rule): void;
+export declare function resetRules(): void;
+export declare function makeFileName(swagger: OpenAPI.Document): string | undefined;
+export declare function makeForm(spec: OpenAPI.Document): string;
+export declare function saveFile(file: string, fileName: string): Promise<void>;
+export declare function loadSpec(fileOrUrlPath: string): Promise<OpenAPI.Document>;

package/dist/generator-lib.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * @license
+ * Licensed under the MIT License, (“the License”); you may not use this
+ * file except in compliance with the License.
+ *
+ * Copyright (c) 2020 Verizon
+ */
+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;
+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];
+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}`;
+}
+function makeForm(spec) {
+    var _a;
+    let definitions;
+    if ('definitions' in spec) {
+        definitions = spec.definitions;
+    }
+    else if ('components' in spec) {
+        definitions = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.schemas;
+    }
+    else {
+        throw new Error('Cannot find schemas/definitions');
+    }
+    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 });
+}
+exports.makeForm = makeForm;
+async function saveFile(file, fileName) {
+    const project = new ts_morph_1.Project();
+    project.createSourceFile(fileName, file, { overwrite: true });
+    return project.save();
+}
+exports.saveFile = saveFile;
+async function loadSpec(fileOrUrlPath) {
+    const parser = new swagger_parser_1.default();
+    return parser.dereference(fileOrUrlPath);
+}
+exports.loadSpec = loadSpec;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generator-lib';
+export * from './rules';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generator-lib"), exports);
+__exportStar(require("./rules"), exports);

package/dist/rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Licensed under the MIT License, (“the License”); you may not use this
+ * file except in compliance with the License.
+ *
+ * Copyright (c) 2020 Verizon
+ */
+import { OpenAPIV2 } from 'openapi-types';
+export declare type Property = {
+    format?: string;
+    pattern?: string;
+    maxLength?: number;
+    minLength?: number;
+    minimum?: number;
+    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;

package/dist/rules.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * @license
+ * Licensed under the MIT License, (“the License”); you may not use this
+ * file except in compliance with the License.
+ *
+ * Copyright (c) 2020 Verizon
+ */
+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 abstractRule(fieldName, definition, ruleName) {
+    return hasMetadata(fieldName, definition, ruleName)
+        ? `Validators.${ruleName}(${definition.properties[fieldName][ruleName]})`
+        : '';
+}
+function requiredRule(fieldName, definition) {
+    return definition.required && definition.required.includes(fieldName) ? `Validators.required` : '';
+}
+exports.requiredRule = requiredRule;
+function patternRule(fieldName, definition) {
+    return hasMetadata(fieldName, definition, 'pattern')
+        ? `Validators.pattern(/${definition.properties[fieldName]['pattern']}/)`
+        : '';
+}
+exports.patternRule = patternRule;
+function minLengthRule(fieldName, definition) {
+    return abstractRule(fieldName, definition, 'minLength');
+}
+exports.minLengthRule = minLengthRule;
+function maxLengthRule(fieldName, definition) {
+    return abstractRule(fieldName, definition, 'maxLength');
+}
+exports.maxLengthRule = maxLengthRule;
+function emailRule(fieldName, definition) {
+    return definition.properties[fieldName].format === 'email' ? `Validators.email` : '';
+}
+exports.emailRule = emailRule;
+function minimumRule(fieldName, definition) {
+    return hasMetadata(fieldName, definition, 'minimum')
+        ? `Validators.min(${definition.properties[fieldName]['minimum']})`
+        : '';
+}
+exports.minimumRule = minimumRule;
+function maximumRule(fieldName, definition) {
+    return hasMetadata(fieldName, definition, 'maximum')
+        ? `Validators.max(${definition.properties[fieldName]['maximum']})`
+        : '';
+}
+exports.maximumRule = maximumRule;

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@jmm-devkit/ngx-form-generator",
+  "version": "1.2.1",
+  "description": "Generates an Angular ReactiveForm from a Swagger or OpenAPI definition",
+  "main": "dist/generator-lib.js",
+  "repository": "github:jmm-devkit/ngx-form-generator",
+  "bin": {
+    "ngx-form-generator": "dist/generator-cli.js"
+  },
+  "scripts": {
+    "test": "npm run build && jasmine dist/*.spec.js",
+    "build": "tsc --project .\\",
+    "lint": "eslint . --ext .ts",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
+  },
+  "author": "Martin McWhorter <martin@mcwhorter.org> (https://github.com/martinmcwhorter)",
+  "license": "MIT",
+  "keywords": [
+    "angular",
+    "validation",
+    "form",
+    "reactive-forms",
+    "swagger",
+    "openapi",
+    "typescript"
+  ],
+  "devDependencies": {
+    "@commitlint/cli": "^17.1.2",
+    "@commitlint/config-conventional": "^17.0.3",
+    "@types/camelcase": "^4.1.0",
+    "@types/jasmine": "^4.3.0",
+    "@types/node-fetch": "^2.5.5",
+    "@types/prettier": "^1.19.1",
+    "@types/yaml": "^1.2.0",
+    "@types/yargs": "^17.0.13",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "commitiquette": "^1.2.1",
+    "commitizen": "^4.2.4",
+    "eslint": "^8.0.1",
+    "eslint-config-prettier": "^6.10.1",
+    "husky": "^7.0.4",
+    "jasmine": "^4.4.0",
+    "lint-staged": "^13.0.3",
+    "openapi-types": "^7.0.1",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.0.2",
+    "camelcase": "^5.0.0",
+    "prettier": "^1.19.1",
+    "ts-morph": "^16.0.0",
+    "yaml": "^2.1.3",
+    "yargs": "^17.6.0"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged",
+      "prepare-commit-msg": "exec < /dev/tty && git cz --hook || true",
+      "commit-msg": "commitLint -E HUSKY_GIT_PARAMS"
+    }
+  },
+  "lint-staged": {
+    "*.{js,css,json,md}": [
+      "prettier --write",
+      "git add"
+    ],
+    "*.ts": [
+      "eslint --fix",
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "config": {
+    "commitizen": {
+      "path": "commitiquette"
+    }
+  }
+}