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

package/node_modules/@deterministic-code/typescript-generators/dist/generate-datasource-type-validators-tests.js

@@ -0,0 +1,167 @@
+import { toNative } from "./deterministic-type-converter.js";
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+  TYPES_YAML
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { fieldSize } from "./common/view-shape.js";
+import { typeTestTmpl } from "./resources/datasource-type-validators-tests.js";
+import {
+  fakeTestData,
+  fieldExpr,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import { bag, Emit } from "./emit.js";
+const MUTABLE_SCALAR = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "datetime",
+  "reference",
+  "binary"
+]);
+const escapeTestName = (name) => name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+const objectLiteral = (fields) => `{ ${fields.map((f) => `${f.ident}: ${f.expr}`).join(", ")} }`;
+const wrongTypeExpr = (type) => {
+  switch (type) {
+    case "string":
+      return "123";
+    case "number":
+    case "reference":
+      return `"not-a-number"`;
+    case "boolean":
+      return `"not-a-boolean"`;
+    case "datetime":
+      return "42";
+    case "binary":
+      return `"not-binary"`;
+    default:
+      return void 0;
+  }
+};
+const fieldTok = (field, fieldIdent, typesByName) => {
+  const ident = fieldIdent(field.name);
+  const specType = fieldTypeOf(field, typesByName);
+  const sampleExpr = fieldExpr(fakeTestData, specType, {
+    nativeType: toNative(specType),
+    size: fieldSize(field)
+  });
+  return {
+    name: field.name,
+    ident,
+    sampleExpr,
+    isNullable: field.isNullable,
+    hasDefault: field.hasDefault === true,
+    type: specType
+  };
+};
+const casesFor = (fields) => {
+  const valid = objectLiteral(
+    fields.map((f) => ({ ident: f.ident, expr: f.sampleExpr }))
+  );
+  const cases = [
+    { name: "parses a valid payload", fixture: valid, assertion: "not.toThrow" }
+  ];
+  if (fields.some((f) => f.isNullable)) {
+    cases.push({
+      name: "accepts null for nullable fields",
+      fixture: objectLiteral(
+        fields.map((f) => ({
+          ident: f.ident,
+          expr: f.isNullable ? "null" : f.sampleExpr
+        }))
+      ),
+      assertion: "not.toThrow"
+    });
+  }
+  for (const field of fields) {
+    if (!field.isNullable && !field.hasDefault) {
+      cases.push({
+        name: escapeTestName(`rejects when missing required field "${field.name}"`),
+        fixture: objectLiteral(
+          fields.filter((f) => f.ident !== field.ident).map((f) => ({ ident: f.ident, expr: f.sampleExpr }))
+        ),
+        assertion: "toThrow"
+      });
+    }
+    if (!field.isNullable) {
+      cases.push({
+        name: escapeTestName(`rejects when null for non-nullable field "${field.name}"`),
+        fixture: objectLiteral(
+          fields.map((f) => ({
+            ident: f.ident,
+            expr: f.ident === field.ident ? "null" : f.sampleExpr
+          }))
+        ),
+        assertion: "toThrow"
+      });
+    }
+    if (MUTABLE_SCALAR.has(field.type)) {
+      const bad = wrongTypeExpr(field.type);
+      if (bad !== void 0) {
+        cases.push({
+          name: escapeTestName(`rejects when wrong type on field "${field.name}"`),
+          fixture: objectLiteral(
+            fields.map((f) => ({
+              ident: f.ident,
+              expr: f.ident === field.ident ? bad : f.sampleExpr
+            }))
+          ),
+          assertion: "toThrow"
+        });
+      }
+    }
+  }
+  return cases;
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return datasourceTypesOf(deterministic).map(
+      (table) => this.tests(table, typesByName)
+    );
+  }
+  tests(table, typesByName) {
+    const fields = persistedColumnFields(table, typesByName).map(
+      (f) => fieldTok(f, (name) => this.casing.fieldIdent(name), typesByName)
+    );
+    const src = this.imports.datasourceValidator(table.name);
+    const schemaName = this.casing.schemaName(table.name);
+    return content(
+      this.imports.test(src, table.name),
+      fill(typeTestTmpl, {
+        prelude: preludeSource(fakeTestData),
+        schemaVersion: this.settings.schemaVersion,
+        schemaName,
+        tableName: table.name,
+        schemaImport: this.imports.testSpec(src, table.name),
+        cases: casesFor(fields)
+      }),
+      bag({
+        module: this.imports.validatorTestRel("datasource", table.name),
+        imports: this.imports.datasourceValidatorRel(table.name),
+        uses: schemaName
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  return withFakerPackagePatch(
+    new Generator(ctx.settings).from(
+      await DeterministicParser(ctx.reader).parse(ctx.settings)
+    )
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-datasource-types-tests.js

@@ -0,0 +1,83 @@
+import { toNative } from "./deterministic-type-converter.js";
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  fieldTypeOf,
+  persistedColumnFields,
+  TYPES_YAML
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { fieldSize } from "./common/view-shape.js";
+import { typeTestTmpl } from "./resources/datasource-types-tests.js";
+import {
+  fakeTestData,
+  fieldExpr,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import { bag, Emit } from "./emit.js";
+const escapeTestName = (name) => name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+const fieldTokens = (field, fieldIdent, typesByName) => {
+  const ident = fieldIdent(field.name);
+  const specType = fieldTypeOf(field, typesByName);
+  const expr = fieldExpr(fakeTestData, specType, {
+    nativeType: toNative(specType),
+    size: fieldSize(field)
+  });
+  return {
+    ident,
+    access: ident.startsWith('"') ? `[${ident}]` : `.${ident}`,
+    testName: escapeTestName(field.name),
+    sampleExpr: expr,
+    nextExpr: expr,
+    nullable: field.isNullable
+  };
+};
+class Generator extends Emit {
+  from(deterministic) {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    return datasourceTypesOf(deterministic).map(
+      (table) => this.tests(table, typesByName)
+    );
+  }
+  tests(table, typesByName) {
+    const fields = persistedColumnFields(table, typesByName).map(
+      (f) => fieldTokens(f, (name) => this.casing.fieldIdent(name), typesByName)
+    );
+    const src = this.imports.datasource(table.name);
+    const className = this.casing.convertTypes(table.name);
+    return content(
+      this.imports.test(src, table.name),
+      fill(typeTestTmpl, {
+        prelude: preludeSource(fakeTestData),
+        schemaVersion: this.settings.schemaVersion,
+        className,
+        tableName: table.name,
+        typeImport: this.imports.testSpec(src, table.name),
+        fixture: `{ ${fields.map((f) => `${f.ident}: ${f.sampleExpr}`).join(", ")} }`,
+        fields
+      }),
+      bag({
+        module: this.imports.datasourceTestRel(table.name),
+        imports: this.imports.datasourceRel(table.name),
+        uses: className
+      })
+    );
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(TYPES_YAML);
+  return withFakerPackagePatch(
+    new Generator(ctx.settings).from(
+      await DeterministicParser(ctx.reader).parse(ctx.settings)
+    )
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-datasource-types.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+export declare const generate: (ctx: GenerateContext) => Promise<GenerateEntry[]>;

package/node_modules/@deterministic-code/typescript-generators/dist/generate-datasource-types.js

@@ -0,0 +1,10 @@
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import { generateShapedTypes } from "./emit-shaped-types.js";
+const generate = async (ctx) => {
+  const entries = await generateShapedTypes(ctx, { kind: "datasource" });
+  verifyEntries(entries);
+  return entries;
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-frontend-app.js

@@ -0,0 +1,154 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content, patch } from "@deterministic-code/generators-common/generate-entry";
+import * as angular from "./resources/frontend-app-angular.js";
+import * as next from "./resources/frontend-app-next.js";
+import * as svelte from "./resources/frontend-app-svelte.js";
+import * as vite from "./resources/frontend-app.js";
+import { Emit } from "./emit.js";
+const frameworks = (imports, casing) => {
+  const appFileBase = casing.fileBase("app");
+  const mainFileBase = casing.fileBase("main");
+  const appConfigFileBase = casing.fileBase("app_config");
+  const appDir = casing.directory("app");
+  return {
+    vite: {
+      scaffold: [
+        { filename: imports.frontend("index.html"), tmpl: vite.indexHtml, kind: "content" },
+        { filename: imports.frontend("vite.config.ts"), tmpl: vite.viteConfigTs, kind: "content" },
+        { filename: imports.frontend("tsconfig.json"), tmpl: vite.tsconfigJson, kind: "content" },
+        {
+          filename: imports.frontend(`src/${mainFileBase}.tsx`),
+          tmpl: vite.mainTsx,
+          kind: "content"
+        },
+        {
+          filename: imports.frontend(`src/${appFileBase}.tsx`),
+          tmpl: vite.appTsx,
+          kind: "content"
+        },
+        { filename: imports.frontend("package.json"), tmpl: vite.packageJson, kind: "patch" },
+        { filename: imports.frontend(".gitignore"), tmpl: vite.gitignore, kind: "patch" }
+      ],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: vite.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND"
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: vite.dockerfile, kind: "content" }
+      ]
+    },
+    next: {
+      scaffold: [
+        { filename: imports.frontend("package.json"), tmpl: next.packageJson, kind: "patch" },
+        { filename: imports.frontend("tsconfig.json"), tmpl: next.tsconfigJson, kind: "content" },
+        { filename: imports.frontend("next.config.ts"), tmpl: next.nextConfigTs, kind: "content" },
+        { filename: imports.frontend("next-env.d.ts"), tmpl: next.nextEnvDts, kind: "content" },
+        { filename: imports.frontend("app/layout.tsx"), tmpl: next.layoutTsx, kind: "content" },
+        { filename: imports.frontend("app/page.tsx"), tmpl: next.pageTsx, kind: "content" },
+        { filename: imports.frontend(".gitignore"), tmpl: next.gitignore, kind: "patch" }
+      ],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: next.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND"
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: next.dockerfile, kind: "content" }
+      ]
+    },
+    svelte: {
+      scaffold: [
+        { filename: imports.frontend("index.html"), tmpl: svelte.indexHtml, kind: "content" },
+        { filename: imports.frontend("vite.config.ts"), tmpl: svelte.viteConfigTs, kind: "content" },
+        { filename: imports.frontend("svelte.config.js"), tmpl: svelte.svelteConfigJs, kind: "content" },
+        { filename: imports.frontend("tsconfig.json"), tmpl: svelte.tsconfigJson, kind: "content" },
+        { filename: imports.frontend("src/vite-env.d.ts"), tmpl: svelte.viteEnvDts, kind: "content" },
+        {
+          filename: imports.frontend(`src/${mainFileBase}.ts`),
+          tmpl: svelte.mainTs,
+          kind: "content"
+        },
+        {
+          filename: imports.frontend(`src/${appFileBase}.svelte`),
+          tmpl: svelte.appSvelte,
+          kind: "content"
+        },
+        { filename: imports.frontend("package.json"), tmpl: svelte.packageJson, kind: "patch" },
+        { filename: imports.frontend(".gitignore"), tmpl: svelte.gitignore, kind: "patch" }
+      ],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: svelte.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND"
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: svelte.dockerfile, kind: "content" }
+      ]
+    },
+    angular: {
+      scaffold: [
+        { filename: imports.frontend("package.json"), tmpl: angular.packageJson, kind: "patch" },
+        { filename: imports.frontend("angular.json"), tmpl: angular.angularJson, kind: "content" },
+        { filename: imports.frontend("tsconfig.json"), tmpl: angular.tsconfigJson, kind: "content" },
+        { filename: imports.frontend("tsconfig.app.json"), tmpl: angular.tsconfigAppJson, kind: "content" },
+        { filename: imports.frontend("src/index.html"), tmpl: angular.indexHtml, kind: "content" },
+        {
+          filename: imports.frontend(`src/${mainFileBase}.ts`),
+          tmpl: angular.mainTs,
+          kind: "content"
+        },
+        { filename: imports.frontend("src/styles.css"), tmpl: angular.stylesCss, kind: "content" },
+        {
+          filename: imports.frontend(`src/${appDir}/${appConfigFileBase}.ts`),
+          tmpl: angular.appConfigTs,
+          kind: "content"
+        },
+        {
+          filename: imports.frontend(`src/${appDir}/${appFileBase}.ts`),
+          tmpl: angular.appTs,
+          kind: "content"
+        },
+        { filename: imports.frontend(".gitignore"), tmpl: angular.gitignore, kind: "patch" }
+      ],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: angular.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND"
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: angular.dockerfile, kind: "content" }
+      ]
+    }
+  };
+};
+class Generator extends Emit {
+  from() {
+    const tokens = {
+      application_name: this.settings.applicationName,
+      appComponentName: this.casing.appComponentName(),
+      homeComponentName: this.casing.homeComponentName(),
+      rootLayoutName: this.casing.rootLayoutName(),
+      appConfigName: this.casing.appConfigName(),
+      appFileBase: this.casing.fileBase("app"),
+      mainFileBase: this.casing.fileBase("main"),
+      appConfigFileBase: this.casing.fileBase("app_config"),
+      appDir: this.casing.directory("app"),
+      mainFile: `${this.casing.fileBase("main")}.ts`
+    };
+    const { scaffold, fullStack } = frameworks(this.imports, this.casing)[this.settings.frontendFramework];
+    const specs = this.settings.fullStack ? [...scaffold, ...fullStack] : [...scaffold];
+    return specs.map((spec) => {
+      const body = fill(spec.tmpl, tokens);
+      return spec.kind === "patch" ? patch(spec.filename, body, spec.section) : content(spec.filename, body);
+    });
+  }
+}
+const generate = async (ctx) => new Generator(ctx.settings).from();
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-frontend-types-tests.js

@@ -0,0 +1,14 @@
+import { Emit } from "./emit.js";
+import { generate as generateViewTypesTests } from "./generate-view-types-tests.js";
+import { referencesBackend } from "./inline-inherited.js";
+const generate = async (ctx) => {
+  const referenceBackendType = referencesBackend(ctx.settings);
+  return generateViewTypesTests(
+    ctx,
+    new Emit(ctx.settings).imports.frontend("src/types"),
+    referenceBackendType
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-frontend-types.js

@@ -0,0 +1,18 @@
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import { Emit } from "./emit.js";
+import { generateViewTypes } from "./emit-shaped-types.js";
+import { referencesBackend } from "./inline-inherited.js";
+const generate = async (ctx) => {
+  const referenceBackendType = referencesBackend(ctx.settings);
+  const views = new Emit(ctx.settings).imports.frontend("src/types");
+  const entries = await generateViewTypes(ctx, {
+    referenceBackendType,
+    basePath: views,
+    datasourceBasePath: referenceBackendType ? "types/generated/datasource" : views
+  });
+  if (!referenceBackendType) verifyEntries(entries);
+  return entries;
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-frontend-validators-tests.js

@@ -0,0 +1,14 @@
+import { Emit } from "./emit.js";
+import { generate as generateViewTypeValidatorsTests } from "./generate-view-type-validators-tests.js";
+import { referencesBackend } from "./inline-inherited.js";
+const generate = async (ctx) => {
+  const referenceBackendType = referencesBackend(ctx.settings);
+  return generateViewTypeValidatorsTests(
+    ctx,
+    new Emit(ctx.settings).imports.frontend("src/validators"),
+    referenceBackendType
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-frontend-validators.js

@@ -0,0 +1,34 @@
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import { Emit } from "./emit.js";
+import { generate as generateViewTypeValidators } from "./generate-view-type-validators.js";
+import { referencesBackend } from "./inline-inherited.js";
+import {
+  indexTmpl,
+  schemaInheritTmpl,
+  schemaStandaloneTmpl,
+  schemaUnionTmpl,
+  typeTmpl
+} from "./resources/frontend-validators.js";
+const generate = async (ctx) => {
+  const referenceBackendType = referencesBackend(ctx.settings);
+  const validators = new Emit(ctx.settings).imports.frontend(
+    "src/validators"
+  );
+  const entries = await generateViewTypeValidators(ctx, {
+    referenceBackendType,
+    templates: {
+      typeTmpl,
+      indexTmpl,
+      schemaUnionTmpl,
+      schemaStandaloneTmpl,
+      schemaInheritTmpl
+    },
+    basePath: validators,
+    datasourceBasePath: referenceBackendType ? "types/generated/datasource/validators" : validators
+  });
+  if (!referenceBackendType) verifyEntries(entries);
+  return entries;
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-perf-e2e-tests.js

@@ -0,0 +1,8 @@
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { e2eTmpl } from "./resources/perf-e2e.js";
+const generate = async (_ctx) => [
+  content("app.perf.client.test.ts", e2eTmpl)
+];
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-perf-server.js

@@ -0,0 +1,31 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content, patch } from "@deterministic-code/generators-common/generate-entry";
+import { TYPES_YAML } from "@deterministic-code/generators-common/spec-types";
+import { createCasing } from "./common/default-casing.js";
+import { serverTmpl, vitestPerfTmpl } from "./resources/perf-server.js";
+const generate = async (ctx) => {
+  if (!await ctx.reader.exists(TYPES_YAML)) {
+    throw new Error("generate-perf-server: types.yaml is required");
+  }
+  await ctx.reader.read(TYPES_YAML);
+  const casing = createCasing(ctx.settings);
+  return [
+    content(
+      "perf-server.ts",
+      fill(serverTmpl, {
+        appFnName: casing.appFnName(),
+        appFileBase: casing.fileBase("app")
+      })
+    ),
+    content("vitest.perf.config.ts", vitestPerfTmpl),
+    patch(
+      "package.json",
+      JSON.stringify({
+        scripts: { "test:perf": "vitest run --config vitest.perf.config.ts" }
+      })
+    )
+  ];
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-routes-e2e-test.js

@@ -0,0 +1,21 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { ROUTES_YAML } from "@deterministic-code/generators-common/spec-types";
+import { createCasing } from "./common/default-casing.js";
+import { e2eTmpl } from "./resources/routes-e2e.js";
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  const casing = createCasing(ctx.settings);
+  return [
+    content(
+      "__tests__/app.integration.test.ts",
+      fill(e2eTmpl, {
+        appFnName: casing.appFnName(),
+        appFileBase: casing.fileBase("app")
+      })
+    )
+  ];
+};
+export {
+  generate
+};

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

@@ -0,0 +1,64 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  isReadonlyLookup,
+  ROUTES_YAML
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  fakeTestData,
+  preludeSource,
+  withFakerPackagePatch
+} from "./common/fake-test-data.js";
+import { crudTmpl, readonlyTmpl } from "./resources/routes-tests.js";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.js";
+import { bag, Emit } from "./emit.js";
+class Generator extends Emit {
+  types;
+  constructor(raw, types) {
+    super(raw);
+    this.types = types;
+  }
+  from(deterministic) {
+    return deterministic.routes.candidates.filter((c) => !isDictionaryCandidate(c)).map((c) => this.test(c));
+  }
+  test(candidate) {
+    const table = this.types.find((d) => d.name === candidate.name);
+    const path = this.imports.routeTest(candidate.name);
+    const routeImport = this.imports.spec(
+      this.imports.routeTestRel(candidate.name),
+      this.imports.routeRel(candidate.name)
+    );
+    const fnName = this.casing.routerFnName(candidate.name);
+    const attrs = bag({
+      module: this.imports.routeTestRel(candidate.name),
+      imports: this.imports.routeRel(candidate.name),
+      uses: fnName
+    });
+    const body = fill(
+      table !== void 0 && isReadonlyLookup(table) ? readonlyTmpl : crudTmpl,
+      {
+        prelude: preludeSource(fakeTestData),
+        fnName,
+        routeImport
+      }
+    );
+    return content(path, body, attrs);
+  }
+}
+const generate = async (ctx) => {
+  await ctx.reader.read(ROUTES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings
+  );
+  return withFakerPackagePatch(
+    new Generator(ctx.settings, deterministic.expandedTypes).from(
+      deterministic
+    )
+  );
+};
+export {
+  generate
+};