@deterministic-code/datasources-cli 0.0.0-stage → 0.1.3

package/node_modules/@deterministic-code/rust-generators/dist/generate-routes-tests.js

@@ -0,0 +1,118 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  identityColumns,
+  isReadonlyLookup,
+  tableByName
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  ROUTES_YAML
+} from "./specification-parser.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import {
+  byFieldGetListTmpl,
+  byFieldGetUniqueTmpl,
+  crudTmpl,
+  readonlyTmpl
+} from "./resources/routes-tests.js";
+import { Emit } from "./emit.js";
+const missingIdExpr = (idType) => idType === "uuid" ? "00000000-0000-0000-0000-000000000000" : "99999";
+const getByFields = (byFields) => byFields.filter((entry) => {
+  const methods = Array.isArray(entry.methods) ? entry.methods : ["GET"];
+  return methods.includes("GET");
+});
+const byFieldsBlock = (entitySnake, mountPath, byFields, fnIdent) => getByFields(byFields).map(
+  (entry) => fill(entry.byFieldUnique ? byFieldGetUniqueTmpl : byFieldGetListTmpl, {
+    entitySnake,
+    mountPath,
+    byField: entry.byField,
+    kebab: entry.byField.replace(/_/g, "-"),
+    byFieldMissingTest: fnIdent(
+      `get_${entitySnake}_by_${entry.byField}_missing_returns_404`
+    ),
+    byFieldListTest: fnIdent(
+      `get_${entitySnake}_by_${entry.byField}_returns_items`
+    )
+  })
+).join("");
+class Generator extends Emit {
+  types;
+  tables;
+  constructor(raw, types, tables) {
+    super(raw);
+    this.types = types;
+    this.tables = tables;
+  }
+  from(deterministic) {
+    return deterministic.routes.candidates.filter((c) => !isDictionaryCandidate(c)).map((c) => this.test(c));
+  }
+  test(candidate) {
+    const type = this.types.find((d) => d.name === candidate.name);
+    const table = this.tables.get(candidate.name);
+    const path = this.imports.routeTest(candidate.name);
+    const mountPath = `/api/${this.imports.apiPath(candidate.name)}`;
+    const occ = this.settings.usesOptimisticConcurrency({
+      tags: type?.tags ?? candidate.tags
+    });
+    const fileBase = this.imports.routeModule(candidate.name);
+    const columns = type !== void 0 ? identityColumns(type, table) : ["id"];
+    const names = columns.length > 0 ? columns : ["id"];
+    const missingId = names.map((column) => {
+      const pkType = type?.fields.find((f) => f.name === column)?.type ?? "integer";
+      return missingIdExpr(pkType);
+    }).join("/");
+    const shared = {
+      fileBase,
+      serviceImport: this.imports.serviceUse(
+        candidate.name,
+        this.casing.serviceClassName(candidate.name)
+      ),
+      className: this.casing.serviceClassName(candidate.name),
+      entitySnake: candidate.name,
+      mountPath,
+      missingId,
+      occ,
+      getListTest: this.casing.fnIdent(
+        `get_${candidate.name}_list_returns_200`
+      ),
+      getMissingTest: this.casing.fnIdent(
+        `get_${candidate.name}_missing_returns_404`
+      ),
+      postTest: this.casing.fnIdent(`post_${candidate.name}_returns_201`),
+      putMissingTest: this.casing.fnIdent(
+        `put_${candidate.name}_missing_is_not_5xx`
+      ),
+      patchMissingTest: this.casing.fnIdent(
+        `patch_${candidate.name}_missing_is_not_5xx`
+      ),
+      deleteMissingTest: this.casing.fnIdent(
+        `delete_${candidate.name}_missing_is_not_5xx`
+      ),
+      byFieldsBlock: byFieldsBlock(
+        candidate.name,
+        mountPath,
+        candidate.byFields,
+        (stem) => this.casing.fnIdent(stem)
+      )
+    };
+    if (type !== void 0 && isReadonlyLookup(type)) {
+      return content(path, fill(readonlyTmpl, shared));
+    }
+    return content(path, fill(crudTmpl, shared));
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings
+  );
+  return new Generator(
+    ctx.settings,
+    deterministic.expandedTypes,
+    tableByName(deterministic)
+  ).from(deterministic);
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-routes.js

@@ -0,0 +1,329 @@
+import pluralize from "pluralize";
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  identityColumns,
+  isReadonlyLookup,
+  tableByName
+} from "@deterministic-code/generators-common/spec-types";
+import { convertSpecType } from "./deterministic-type-converter.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import {
+  DeterministicParser,
+  ROUTES_YAML
+} from "./specification-parser.js";
+import {
+  appWiringBodyTmpl,
+  appWiringTmpl,
+  byFieldMergeTmpl,
+  checkEagerChildTmpl,
+  checkOptionalTypedTmpl,
+  checkRequiredTmpl,
+  checkRequiredTypedTmpl,
+  coerceRowTmpl,
+  crudTmpl,
+  readonlyTmpl,
+  validatorEmptyTmpl,
+  validatorTmpl
+} from "./resources/routes.js";
+import { Emit } from "./emit.js";
+const pluralSnakeField = (entity) => {
+  const parts = entity.split(/[_-]/);
+  parts[parts.length - 1] = pluralize.plural(parts[parts.length - 1]);
+  return parts.join("_");
+};
+const normalizeByFields = (byFields) => byFields.map((e) => {
+  if (!e.byField) return null;
+  const methods = Array.isArray(e.methods) ? e.methods.filter((m) => m === "GET") : ["GET"];
+  if (methods.length === 0) return null;
+  return { byField: e.byField, unique: e.byFieldUnique === true };
+}).filter((e) => e !== null);
+const rustStrSlice = (names) => names.length > 0 ? `&[${names.map((n) => JSON.stringify(n)).join(", ")}]` : "&[]";
+const byFieldPrimitiveCall = (entitySnake, apiPath, entry, hasCoercion) => fill(byFieldMergeTmpl, {
+  entitySnake,
+  path: `/api/${apiPath}`,
+  byField: entry.byField,
+  unique: entry.unique ? "true" : "false",
+  coerceExpr: hasCoercion ? "Some(Arc::new(|row: &mut RowMap| coerce_row_types(row)))" : "None"
+}).trimEnd();
+const byFieldMergeChain = (entitySnake, apiPath, normalizedByFields, hasCoercion) => normalizedByFields.map((e) => byFieldPrimitiveCall(entitySnake, apiPath, e, hasCoercion)).join("\n");
+const fieldTypeCheck = (type) => {
+  switch (type) {
+    case "string":
+    case "uuid":
+      return "is_string";
+    case "number":
+    case "biginteger":
+    case "reference":
+      return "is_number";
+    case "boolean":
+      return "is_boolean";
+    case "datetime":
+      return "is_string";
+    default:
+      return null;
+  }
+};
+const buildEagerChildShapeCheck = (child) => fill(checkEagerChildTmpl, {
+  name: child.fieldName,
+  nameJson: JSON.stringify(child.fieldName)
+}).trimEnd();
+const requiredFieldCheck = (f, requireAll) => {
+  const typeCheck = fieldTypeCheck(f.type);
+  if (requireAll) {
+    if (typeCheck) {
+      return fill(checkRequiredTypedTmpl, {
+        name: f.name,
+        typeCheck,
+        type: f.type
+      }).trimEnd();
+    }
+    return fill(checkRequiredTmpl, { name: f.name }).trimEnd();
+  }
+  if (typeCheck) {
+    return fill(checkOptionalTypedTmpl, {
+      name: f.name,
+      typeCheck,
+      type: f.type
+    }).trimEnd();
+  }
+  return "";
+};
+const buildValidatorFn = (args) => {
+  const checks = [
+    ...args.requiredFields.map((f) => requiredFieldCheck(f, args.requireAll)),
+    ...args.directFkChildren.map(buildEagerChildShapeCheck)
+  ].filter((s) => s.length > 0).join("\n");
+  if (checks.length === 0) {
+    return fill(validatorEmptyTmpl, { fnName: args.fnName }).trimEnd();
+  }
+  return fill(validatorTmpl, { fnName: args.fnName, checks }).trimEnd();
+};
+const generateCoerceRowFn = (booleanFields, binaryFields) => fill(coerceRowTmpl, {
+  boolCols: rustStrSlice(booleanFields.map((f) => f.name)),
+  binCols: rustStrSlice(binaryFields.map((f) => f.name))
+}).trimEnd();
+const partitionFieldsByType = (fields) => ({
+  booleanFields: fields.filter((f) => f.type === "boolean"),
+  binaryFields: fields.filter((f) => f.type === "binary")
+});
+const idTypeVariantForPk = (primaryKey) => {
+  switch (primaryKey.idType) {
+    case "uuid":
+      return "Uuid";
+    case "string":
+      return "String";
+    case "integer":
+    case "biginteger":
+      return "Integer";
+    default:
+      return primaryKey.rustType === "String" ? "String" : "Integer";
+  }
+};
+const inferPrimaryKey = (type, table) => inferPrimaryKeys(type, table)[0];
+const inferPrimaryKeys = (type, table) => {
+  const columns = type !== void 0 ? identityColumns(type, table) : ["id"];
+  const names = columns.length > 0 ? columns : ["id"];
+  return names.map((column) => {
+    const field = type?.fields.find((f) => f.name === column);
+    const pkType = field?.type ?? "integer";
+    if (column !== "id" && field !== void 0) {
+      return {
+        column,
+        rustType: field.type === "number" ? "i64" : "String",
+        idType: pkType
+      };
+    }
+    return {
+      column,
+      rustType: convertSpecType(field?.type ?? "integer"),
+      idType: pkType
+    };
+  });
+};
+const sortedDirectFkChildren = (eagerWriteChildren) => eagerWriteChildren.filter((c) => (c.kind ?? "direct-fk") === "direct-fk").slice().sort((a, b) => a.fieldName.localeCompare(b.fieldName));
+const eagerWriteChildrenForEntity = (entity, nested) => nested.filter(
+  (d) => d.kind === "direct-fk" && d.parent === entity
+).map((d) => ({
+  fieldName: pluralSnakeField(d.child.name),
+  fkColumn: d.fkColumn,
+  childTable: d.child.name,
+  kind: "direct-fk"
+}));
+const fieldsForEntity = (entity, types) => {
+  const ds = types.find((d) => d.name === entity);
+  if (ds === void 0) return [];
+  return ds.fields.map((f) => ({
+    name: f.name,
+    type: f.type,
+    isNullable: f.isNullable,
+    hasDefault: f.hasDefault
+  }));
+};
+const buildCrudValidators = (createFnName, updateFnName, effectiveRequiredFields, children) => ({
+  createValidator: buildValidatorFn({
+    fnName: createFnName,
+    requiredFields: effectiveRequiredFields,
+    requireAll: true,
+    directFkChildren: children
+  }),
+  updateValidator: buildValidatorFn({
+    fnName: updateFnName,
+    requiredFields: effectiveRequiredFields,
+    requireAll: false,
+    directFkChildren: children
+  })
+});
+class Generator extends Emit {
+  types;
+  tables;
+  nested;
+  constructor(raw, types, tables, nested) {
+    super(raw);
+    this.types = types;
+    this.tables = tables;
+    this.nested = nested;
+  }
+  typeOf(name) {
+    return this.types.find((t) => t.name === name);
+  }
+  from(deterministic) {
+    const candidates = deterministic.routes.candidates.filter(
+      (c) => !isDictionaryCandidate(c)
+    );
+    const entries = candidates.map(
+      (c) => this.entityRouter(c)
+    );
+    if (candidates.length > 0) {
+      entries.push(this.appWiring(candidates));
+    }
+    return entries;
+  }
+  entityRouter(candidate) {
+    const type = this.typeOf(candidate.name);
+    return type !== void 0 && isReadonlyLookup(type) ? this.readOnly(candidate) : this.crud(candidate);
+  }
+  readOnly(candidate) {
+    const entitySnake = candidate.name;
+    const className = this.casing.serviceClassName(entitySnake);
+    const path = `/api/${this.imports.apiPath(entitySnake)}`;
+    const pk = inferPrimaryKey(
+      this.typeOf(entitySnake),
+      this.tables.get(entitySnake)
+    );
+    const normalizedByFields = normalizeByFields(candidate.byFields);
+    const tokens = {
+      serviceImport: this.imports.serviceUse(entitySnake, className),
+      className,
+      entitySnake,
+      path,
+      idTypeVariant: idTypeVariantForPk(pk),
+      hasByFields: normalizedByFields.length > 0,
+      byFieldMerges: byFieldMergeChain(
+        entitySnake,
+        this.imports.apiPath(entitySnake),
+        normalizedByFields,
+        false
+      )
+    };
+    return content(this.imports.route(entitySnake), fill(readonlyTmpl, tokens));
+  }
+  crud(candidate) {
+    const entitySnake = candidate.name;
+    const className = this.casing.serviceClassName(entitySnake);
+    const path = `/api/${this.imports.apiPath(entitySnake)}`;
+    const allFields = fieldsForEntity(entitySnake, this.types);
+    const eagerWriteChildren = eagerWriteChildrenForEntity(
+      entitySnake,
+      this.nested
+    );
+    const keys = inferPrimaryKeys(
+      this.typeOf(entitySnake),
+      this.tables.get(entitySnake)
+    );
+    const pk = keys[0];
+    const normalizedByFields = normalizeByFields(candidate.byFields);
+    const hasByFields = normalizedByFields.length > 0;
+    const directFkChildren = sortedDirectFkChildren(eagerWriteChildren);
+    const { booleanFields, binaryFields } = partitionFieldsByType(allFields);
+    const hasCoercion = booleanFields.length + binaryFields.length > 0;
+    const coerceFn = hasCoercion ? `
+
+${generateCoerceRowFn(booleanFields, binaryFields)}` : "";
+    const createValidatorName = this.casing.fnIdent(
+      `validate_create_${entitySnake}`
+    );
+    const updateValidatorName = this.casing.fnIdent(
+      `validate_update_${entitySnake}`
+    );
+    const { createValidator, updateValidator } = buildCrudValidators(
+      createValidatorName,
+      updateValidatorName,
+      [],
+      directFkChildren
+    );
+    const type = this.typeOf(candidate.name);
+    const occ = this.settings.usesOptimisticConcurrency({
+      tags: type?.tags ?? candidate.tags
+    });
+    const tokens = {
+      serviceImport: this.imports.serviceUse(entitySnake, className),
+      className,
+      entitySnake,
+      path,
+      idTypeVariant: idTypeVariantForPk(pk),
+      primaryKeyParamExpr: pk.column === "id" ? "None" : `Some("${pk.column}".to_string())`,
+      primaryKeyParamsExpr: keys.length > 1 ? `vec![${keys.map((k) => `"${k.column}".to_string()`).join(", ")}]` : "vec![]",
+      useOptimisticConcurrency: occ ? "true" : "false",
+      coerceRowExpr: hasCoercion ? "Some(Arc::new(|row: &mut RowMap| coerce_row_types(row)))" : "None",
+      hasCoercion,
+      hasByFields,
+      createValidatorName,
+      updateValidatorName,
+      createValidator,
+      updateValidator,
+      coerceFn,
+      byFieldMerges: byFieldMergeChain(
+        entitySnake,
+        this.imports.apiPath(entitySnake),
+        normalizedByFields,
+        hasCoercion
+      )
+    };
+    return content(this.imports.route(entitySnake), fill(crudTmpl, tokens));
+  }
+  appWiring(candidates) {
+    const services = candidates.map((c) => ({
+      fieldName: this.casing.convertFields(`${c.name}_service`),
+      className: this.casing.serviceClassName(c.name),
+      routeModule: this.imports.spec("", this.imports.routeRel(c.name))
+    }));
+    return content(
+      this.imports.appWiring(),
+      fill(appWiringTmpl, {
+        imports: candidates.map(
+          (c) => this.imports.serviceUse(c.name, this.casing.serviceClassName(c.name))
+        ),
+        body: fill(appWiringBodyTmpl, {
+          hasServices: services.length > 0,
+          services
+        }).trimEnd()
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings
+  );
+  return new Generator(
+    ctx.settings,
+    deterministic.expandedTypes,
+    tableByName(deterministic),
+    deterministic.routes.nested
+  ).from(deterministic);
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-service-integration-tests.js

@@ -0,0 +1,65 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  identityColumns,
+  isManyToMany,
+  tableByName
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  SERVICES_YAML
+} from "./specification-parser.js";
+import { genericTmpl } from "./resources/service-integration-tests.js";
+import { Emit } from "./emit.js";
+const typeByName = (name, types) => types.find((d) => d.name === name);
+const missingIdExpr = (idType) => idType === "uuid" ? `"00000000-0000-0000-0000-000000000000"` : "99999";
+const missingIdentityJson = (type, columns) => {
+  const names = columns.length > 0 ? columns : ["id"];
+  const part = (column) => {
+    const pkType = type?.fields.find((f) => f.name === column)?.type ?? "integer";
+    return missingIdExpr(pkType);
+  };
+  if (names.length === 1) return part(names[0]);
+  return `{${names.map((n) => `"${n}":${part(n)}`).join(",")}}`;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const { generics } = deterministic.services;
+    const types = datasourceTypesOf(deterministic);
+    const tables = tableByName(deterministic);
+    return generics.filter((c) => {
+      const type = typeByName(c.name, types);
+      return type !== void 0 && isManyToMany(type);
+    }).map((c) => {
+      const type = typeByName(c.name, types);
+      const columns = type !== void 0 ? identityColumns(type, tables.get(c.name)) : ["id"];
+      const withUuid = type?.fields.some((f) => f.name === "uuid") === true;
+      return content(
+        this.imports.serviceIntegrationTest(c.name),
+        fill(genericTmpl, {
+          structName: this.casing.serviceClassName(c.name),
+          fileBase: this.casing.fileBase(`${c.name}_service`),
+          entity: c.name,
+          withUuid,
+          addPopulatesTest: this.casing.fnIdent(
+            withUuid ? "add_inserts_a_row_and_auto_populates_id_uuid_created_updated" : "add_inserts_a_row_and_auto_populates_id_created_updated"
+          ),
+          missingId: missingIdentityJson(type, columns)
+        })
+      );
+    });
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const generator = new Generator(ctx.settings);
+  return generator.from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings, {
+      serviceClassName: (entity) => generator.casing.serviceClassName(entity)
+    })
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-service-tests.js

@@ -0,0 +1,51 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  identityColumns,
+  tableByName
+} from "@deterministic-code/generators-common/spec-types";
+import { DeterministicParser, SERVICES_YAML } from "./specification-parser.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import { genericTmpl } from "./resources/service-tests.js";
+import { Emit } from "./emit.js";
+const missingIdExpr = (idType) => idType === "uuid" ? `"00000000-0000-0000-0000-000000000000"` : "99999";
+const missingIdentityJson = (type, columns) => {
+  const names = columns.length > 0 ? columns : ["id"];
+  const part = (column) => {
+    const pkType = type?.fields.find((f) => f.name === column)?.type ?? "integer";
+    return missingIdExpr(pkType);
+  };
+  if (names.length === 1) return part(names[0]);
+  return `{${names.map((n) => `"${n}":${part(n)}`).join(",")}}`;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const tables = tableByName(deterministic);
+    const types = datasourceTypesOf(deterministic);
+    return deterministic.services.generics.filter((c) => !isDictionaryCandidate(c)).map((c) => {
+      const type = types.find((t) => t.name === c.name);
+      const columns = type !== void 0 ? identityColumns(type, tables.get(c.name)) : ["id"];
+      return content(
+        this.imports.serviceTest(c.name),
+        fill(genericTmpl, {
+          structName: this.casing.serviceClassName(c.name),
+          fileBase: this.casing.fileBase(`${c.name}_service`),
+          missingId: missingIdentityJson(type, columns)
+        })
+      );
+    });
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const generator = new Generator(ctx.settings);
+  return generator.from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings, {
+      serviceClassName: (entity) => generator.casing.serviceClassName(entity)
+    })
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/rust-generators/dist/generate-services.js

@@ -0,0 +1,75 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  DeterministicParser,
+  SERVICES_YAML
+} from "./specification-parser.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import { customStubTmpl, genericTmpl } from "./resources/services.js";
+import { Emit } from "./emit.js";
+const STATUS_OK_DEFAULTS = {
+  HealthCheckService: {
+    check: `Ok(json!({ "status": "ok" }))`
+  }
+};
+const defaultBodyFor = (serviceName, method) => {
+  const known = STATUS_OK_DEFAULTS[serviceName]?.[method];
+  if (known !== void 0) return known;
+  return `Ok(serde_json::json!({}))`;
+};
+const useJsonMacro = (serviceName) => Object.prototype.hasOwnProperty.call(STATUS_OK_DEFAULTS, serviceName);
+class Generator extends Emit {
+  from(deterministic) {
+    const customs = deterministic.services.customs;
+    const generics = deterministic.services.generics.filter(
+      (c) => !isDictionaryCandidate(c)
+    );
+    return [
+      ...generics.map((c) => this.generic(c)),
+      ...customs.map((c) => this.custom(c))
+    ];
+  }
+  generic(candidate) {
+    const structName = this.casing.serviceClassName(candidate.name);
+    return content(
+      this.imports.service(candidate.name),
+      fill(genericTmpl, {
+        structName,
+        entitySnakeLiteral: JSON.stringify(candidate.name)
+      })
+    );
+  }
+  custom(entry) {
+    const structName = this.casing.convertTypes(entry.name);
+    const methods = entry.methods.map((method) => ({
+      rustFn: this.casing.convertFields(method),
+      body: defaultBodyFor(entry.name, method)
+    }));
+    return content(
+      this.imports.serviceCustom(entry.name, entry.module),
+      fill(customStubTmpl, {
+        structName,
+        useJsonMacro: useJsonMacro(entry.name),
+        hasMethods: methods.length > 0,
+        methods,
+        invokeArms: entry.methods.map((method) => ({
+          method,
+          rustFn: this.casing.convertFields(method)
+        })),
+        argsParam: methods.length === 0 ? "_args" : "args"
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(SERVICES_YAML);
+  const generator = new Generator(ctx.settings);
+  return generator.from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings, {
+      serviceClassName: (entity) => generator.casing.serviceClassName(entity)
+    })
+  );
+};
+export {
+  generate
+};