@api-platform/client-generator/lib/generators/NextGenerator.js

Generate apps built with Next, Nuxt, Quasar, React, React Native, Vue or Vuetify for any API documented using Hydra or OpenAPI

import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _inherits from "@babel/runtime/helpers/inherits";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

import chalk from "chalk";
import handlebars from "handlebars";
import hbhComparison from "handlebars-helpers/lib/comparison.js";
import hbhString from "handlebars-helpers/lib/string.js";
import BaseGenerator from "./BaseGenerator.js";

var NextGenerator = /*#__PURE__*/function (_BaseGenerator) {
  _inherits(NextGenerator, _BaseGenerator);

  var _super = _createSuper(NextGenerator);

  function NextGenerator(params) {
    var _this;

    _classCallCheck(this, NextGenerator);

    _this = _super.call(this, params);
    _this.routeAddedtoServer = false;

    _this.registerTemplates("next/", [// components
    "components/common/Layout.tsx", "components/common/Pagination.tsx", "components/common/ReferenceLinks.tsx", "components/foo/List.tsx", "components/foo/Show.tsx", "components/foo/Form.tsx", // types
    "types/collection.ts", "types/foo.ts", "types/item.ts", // pages
    "pages/foos/[id]/index.tsx", "pages/foos/[id]/edit.tsx", "pages/foos/index.tsx", "pages/foos/create.tsx", "pages/_app.tsx", // utils
    "utils/dataAccess.ts", "utils/mercure.ts"]);

    handlebars.registerHelper("compare", hbhComparison.compare);
    handlebars.registerHelper("lowercase", hbhString.lowercase);
    return _this;
  }

  _createClass(NextGenerator, [{
    key: "help",
    value: function help(resource) {
      console.log(chalk.green('Code for the "%s" resource type has been generated!'), resource.title);
    }
  }, {
    key: "generate",
    value: function generate(api, resource, dir) {
      var _this2 = this;

      var lc = resource.title.toLowerCase();
      var ucf = this.ucFirst(resource.title);

      var _this$parseFields = this.parseFields(resource),
          fields = _this$parseFields.fields,
          imports = _this$parseFields.imports;

      var context = {
        name: resource.name,
        lc: lc,
        uc: resource.title.toUpperCase(),
        ucf: ucf,
        fields: fields,
        formFields: this.buildFields(fields),
        imports: imports,
        hydraPrefix: this.hydraPrefix,
        title: resource.title,
        hasRelations: fields.some(function (field) {
          return field.reference || field.embedded;
        }),
        hasManyRelations: fields.some(function (field) {
          return field.isReferences || field.isEmbeddeds;
        })
      }; // Create directories
      // These directories may already exist

      ["".concat(dir, "/components/common"), "".concat(dir, "/config"), "".concat(dir, "/error"), "".concat(dir, "/types"), "".concat(dir, "/utils")].forEach(function (dir) {
        return _this2.createDir(dir, false);
      }); // Copy with patterned name

      this.createDir("".concat(dir, "/components/").concat(context.lc));
      this.createDir("".concat(dir, "/pages/").concat(context.lc, "s"));
      this.createDir("".concat(dir, "/pages/").concat(context.lc, "s/[id]"));
      [// components
      "components/%s/List.tsx", "components/%s/Show.tsx", "components/%s/Form.tsx", // pages
      "pages/%ss/[id]/index.tsx", "pages/%ss/[id]/edit.tsx", "pages/%ss/index.tsx", "pages/%ss/create.tsx"].forEach(function (pattern) {
        return _this2.createFileFromPattern(pattern, dir, context.lc, context);
      }); // interface pattern should be camel cased

      this.createFile("types/foo.ts", "".concat(dir, "/types/").concat(context.ucf, ".ts"), context); // copy with regular name

      [// components
      "components/common/Layout.tsx", "components/common/Pagination.tsx", "components/common/ReferenceLinks.tsx", // types
      "types/collection.ts", "types/item.ts", // pages
      "pages/_app.tsx", // utils
      "utils/dataAccess.ts", "utils/mercure.ts"].forEach(function (file) {
        return _this2.createFile(file, "".concat(dir, "/").concat(file), context, false);
      }); // API config

      this.createEntrypoint(api.entrypoint, "".concat(dir, "/config/entrypoint.ts"));
    }
  }, {
    key: "getDescription",
    value: function getDescription(field) {
      return field.description ? field.description.replace(/"/g, "'") : "";
    }
  }, {
    key: "parseFields",
    value: function parseFields(resource) {
      var _this3 = this;

      var fields = [].concat(_toConsumableArray(resource.writableFields), _toConsumableArray(resource.readableFields)).reduce(function (list, field) {
        if (list[field.name]) {
          return list;
        }

        var isReferences = field.reference && field.maxCardinality !== 1;
        var isEmbeddeds = field.embedded && field.maxCardinality !== 1;
        return _objectSpread(_objectSpread({}, list), {}, _defineProperty({}, field.name, _objectSpread(_objectSpread({}, field), {}, {
          type: _this3.getType(field),
          description: _this3.getDescription(field),
          readonly: false,
          isReferences: isReferences,
          isEmbeddeds: isEmbeddeds,
          isRelations: isEmbeddeds || isReferences
        })));
      }, {}); // Parse fields to add relevant imports, required for Typescript

      var fieldsArray = Object.values(fields);
      var imports = Object.values(fields).reduce(function (list, _ref) {
        var reference = _ref.reference,
            type = _ref.type;

        if (!reference) {
          return list;
        }

        return _objectSpread(_objectSpread({}, list), {}, _defineProperty({}, type, {
          type: type,
          file: "./".concat(type)
        }));
      }, {});
      return {
        fields: fieldsArray,
        imports: Object.values(imports)
      };
    }
  }, {
    key: "ucFirst",
    value: function ucFirst(target) {
      return target.charAt(0).toUpperCase() + target.slice(1);
    }
  }]);

  return NextGenerator;
}(BaseGenerator);

export { NextGenerator as default };