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

package/node_modules/@deterministic-code/rust-generators/src/generate-service-tests.ts

@@ -0,0 +1,64 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  datasourceTypesOf,
+  identityColumns,
+  tableByName,
+} from "@deterministic-code/generators-common/spec-types";
+import { DeterministicParser, SERVICES_YAML, type IDeterministic } from "./specification-parser.ts";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.ts";
+import { genericTmpl } from "./resources/service-tests.ts";
+import { Emit } from "./emit.ts";
+
+const missingIdExpr = (idType: string): string =>
+  idType === "uuid"
+    ? `"00000000-0000-0000-0000-000000000000"`
+    : "99999";
+
+const missingIdentityJson = (
+  type: { fields: Array<{ name: string; type: string }> } | undefined,
+  columns: string[],
+): string => {
+  const names = columns.length > 0 ? columns : ["id"];
+  const part = (column: string): string => {
+    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: IDeterministic): GenerateEntry[] {
+    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 !== undefined ? 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),
+          }),
+        );
+      });
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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),
+    }),
+  );
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-services.ts

@@ -0,0 +1,86 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  DeterministicParser,
+  SERVICES_YAML,
+  type CustomServiceEntry,
+  type ServiceCandidate,
+  type IDeterministic,
+} from "./specification-parser.ts";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.ts";
+import { customStubTmpl, genericTmpl } from "./resources/services.ts";
+import { Emit } from "./emit.ts";
+
+const STATUS_OK_DEFAULTS: Record<string, Record<string, string>> = {
+  HealthCheckService: {
+    check: `Ok(json!({ "status": "ok" }))`,
+  },
+};
+
+const defaultBodyFor = (serviceName: string, method: string): string => {
+  const known = STATUS_OK_DEFAULTS[serviceName]?.[method];
+  if (known !== undefined) return known;
+  return `Ok(serde_json::json!({}))`;
+};
+
+const useJsonMacro = (serviceName: string): boolean =>
+  Object.prototype.hasOwnProperty.call(STATUS_OK_DEFAULTS, serviceName);
+
+class Generator extends Emit {
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    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)),
+    ];
+  }
+
+  private generic(candidate: ServiceCandidate): GenerateEntry {
+    const structName = this.casing.serviceClassName(candidate.name);
+    return content(
+      this.imports.service(candidate.name),
+      fill(genericTmpl, {
+        structName,
+        entitySnakeLiteral: JSON.stringify(candidate.name),
+      }),
+    );
+  }
+
+  private custom(entry: CustomServiceEntry): GenerateEntry {
+    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",
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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),
+    }),
+  );
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-view-type-validators-tests.ts

@@ -0,0 +1,105 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import { isUnionEnum } from "./common/view-shape.ts";
+import {
+  shapedToks,
+  viewExpr,
+  type ViewTestOpts,
+} from "./common/view-test-fixtures.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+} from "./specification-parser.ts";
+import { typeTestTmpl } from "./resources/view-type-validators-tests.ts";
+import { Emit } from "./emit.ts";
+
+const shapedCases = (view: Type, opts: ViewTestOpts) => {
+  const fields = shapedToks(view, opts, new Set([view.name]));
+  const cls = opts.casing.convertTypes(view.name);
+  const cases = [
+    {
+      ident: "parses_a_valid_payload",
+      fixture: `${cls} { ${fields.map((f) => `${f.ident}: ${f.sampleExpr}`).join(", ")} }`,
+      assertion: "is_ok()",
+    },
+  ];
+  if (fields.some((f) => f.nullable)) {
+    cases.push({
+      ident: "accepts_none_for_nullable_fields",
+      fixture: `${cls} { ${fields.map((f) => `${f.ident}: ${f.nullable ? "None" : f.sampleExpr}`).join(", ")} }`,
+      assertion: "is_ok()",
+    });
+  }
+  return cases;
+};
+
+const unionCases = (view: Type, opts: ViewTestOpts) => {
+  const cls = opts.casing.convertTypes(view.name);
+  return (view.union ?? []).map((name) => ({
+    ident: opts.casing.fnIdent(`accepts_${name}_member`),
+    fixture: `${cls}::${opts.casing.convertTypes(name)}(${viewExpr(name, opts, new Set([view.name]))})`,
+    assertion: "is_ok()",
+  }));
+};
+
+class Generator extends Emit implements ViewTestOpts {
+  readonly tables: ViewTestOpts["tables"];
+  readonly views: ViewTestOpts["views"];
+  readonly expandedViews: ViewTestOpts["expandedViews"];
+  readonly typesByName: ViewTestOpts["typesByName"];
+  readonly datasourceNames: ViewTestOpts["datasourceNames"];
+
+  constructor(raw: Record<string, string>, deterministic: IDeterministic) {
+    super(raw);
+    this.tables = new Map(
+      datasourceTypesOf(deterministic).map((t) => [t.name, t]),
+    );
+    this.views = new Map(
+      authoredViewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+    this.expandedViews = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    this.datasourceNames = new Set(this.tables.keys());
+  }
+
+  from(): GenerateEntry[] {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+
+  private tests(view: Type): GenerateEntry {
+    const src = this.imports.view(view.name);
+    return content(
+      this.imports.test(src, view.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        typeUse: this.imports.viewQual(view.name),
+        fnName: this.casing.convertFields(`validate_${view.name}`),
+        cases: isUnionEnum(view)
+          ? unionCases(view, this)
+          : shapedCases(view, this),
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(
+    ctx.settings,
+    await DeterministicParser(ctx.reader).parse(ctx.settings),
+  ).from();
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-view-type-validators.ts

@@ -0,0 +1,154 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  emitViewFields,
+  fieldRefKind,
+  isAlias,
+  isUnionEnum,
+  wrapsInheritedDatasource,
+} from "./common/view-shape.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import {
+  checkArrayNullableTmpl,
+  checkArrayTmpl,
+  checkNullableTmpl,
+  checkRequiredTmpl,
+  typeTmpl,
+} from "./resources/view-type-validators.ts";
+import { Emit } from "./emit.ts";
+
+class Generator extends Emit {
+  private readonly typesByName: Map<string, Type>;
+  private readonly datasourceNames: Set<string>;
+  private readonly expandedByName: Map<string, Type>;
+
+  constructor(raw: Record<string, string>, deterministic: IDeterministic) {
+    super(raw);
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    this.datasourceNames = new Set(
+      datasourceTypesOf(deterministic).map((t) => t.name),
+    );
+    this.expandedByName = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+  }
+
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    return authoredViewTypesOf(deterministic).map((view) =>
+      this.view(view, this.expandedByName.get(view.name)),
+    );
+  }
+
+  private typePath(entity: string, kind: "datasource" | "view"): string {
+    return kind === "datasource"
+      ? this.imports.datasourceQual(entity)
+      : this.imports.viewQual(entity);
+  }
+
+  private validatorFn(entity: string, kind: "datasource" | "view"): string {
+    const fn =
+      kind === "datasource"
+        ? this.casing.convertFields(`validate_datasource_${entity}`)
+        : this.casing.convertFields(`validate_${entity}`);
+    return this.imports.validatorFn(kind, entity, fn);
+  }
+
+  private checkField(field: TypeField): string {
+    const prop = this.casing.convertFields(field.name);
+    const access = `obj.${prop}`;
+    if (field.isMap === true) {
+      const dict = dictionaryOfField(field, this.typesByName);
+      const entry = dict === undefined ? undefined : dictionaryEntryFields(dict);
+      if (entry === undefined) return "";
+      const refKind = fieldRefKind(entry.value, this.typesByName);
+      if (refKind === "primitive") return "";
+      const fn = this.validatorFn(entry.value.base, refKind);
+      return `    for item in ${access}.values() { if let Err(mut e) = ${fn}(item) { errors.append(&mut e); } }`;
+    }
+    const refKind = fieldRefKind(field, this.typesByName);
+    if (refKind === "primitive") return "";
+    const fn = this.validatorFn(field.base, refKind);
+    if (field.isArray) {
+      const tmpl = field.isNullable ? checkArrayNullableTmpl : checkArrayTmpl;
+      return fill(tmpl, { access, fn }).trimEnd();
+    }
+    if (field.isNullable) {
+      return fill(checkNullableTmpl, { access, fn }).trimEnd();
+    }
+    return fill(checkRequiredTmpl, { fn, arg: `&${access}` }).trimEnd();
+  }
+
+  private shapedBody(view: Type, expanded: Type | undefined): string[] {
+    const checks: string[] = [];
+    const extras = emitViewFields(view, expanded, this.datasourceNames);
+    if (isAlias(view) && extras.length === 0) {
+      const fn = this.validatorFn(view.name, "datasource");
+      checks.push(fill(checkRequiredTmpl, { fn, arg: "obj" }).trimEnd());
+    } else if (isAlias(view)) {
+      const fn = this.validatorFn(view.name, "datasource");
+      checks.push(fill(checkRequiredTmpl, { fn, arg: "&obj.base" }).trimEnd());
+    } else if (wrapsInheritedDatasource(view, this.datasourceNames)) {
+      const fn = this.validatorFn(view.inherits!, "datasource");
+      checks.push(fill(checkRequiredTmpl, { fn, arg: "&obj.base" }).trimEnd());
+    }
+    for (const line of extras.map((f) => this.checkField(f))) {
+      if (line !== "") checks.push(line);
+    }
+    return checks;
+  }
+
+  private view(view: Type, expanded: Type | undefined): GenerateEntry {
+    const fnName = this.casing.convertFields(`validate_${view.name}`);
+    const path = this.imports.viewValidator(view.name);
+    const isUnion = isUnionEnum(view);
+    const enumName = this.casing.convertTypes(view.name);
+    const arms = (view.union ?? []).map((name) => {
+      const variant = this.casing.convertTypes(name);
+      const fn = this.validatorFn(name, "view");
+      return {
+        arm: `${enumName}::${variant}(inner) => ${fn}(inner),`,
+      };
+    });
+    const checks = isUnion ? [] : this.shapedBody(view, expanded);
+    return content(
+      path,
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        isUnion,
+        isShaped: !isUnion,
+        fnName,
+        typePath: this.typePath(view.name, "view"),
+        paramName: checks.length > 0 ? "obj" : "_obj",
+        hasChecks: checks.length > 0,
+        checks: checks.map((line) => ({ line })),
+        arms,
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings,
+  );
+  return new Generator(ctx.settings, deterministic).from(deterministic);
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-view-types-tests.ts

@@ -0,0 +1,92 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import { isUnionEnum } from "./common/view-shape.ts";
+import {
+  shapedToks,
+  viewExpr,
+  type ViewTestOpts,
+} from "./common/view-test-fixtures.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+} from "./specification-parser.ts";
+import { typeTestTmpl } from "./resources/view-types-tests.ts";
+import { Emit } from "./emit.ts";
+
+class Generator extends Emit implements ViewTestOpts {
+  readonly tables: ViewTestOpts["tables"];
+  readonly views: ViewTestOpts["views"];
+  readonly expandedViews: ViewTestOpts["expandedViews"];
+  readonly typesByName: ViewTestOpts["typesByName"];
+  readonly datasourceNames: ViewTestOpts["datasourceNames"];
+
+  constructor(raw: Record<string, string>, deterministic: IDeterministic) {
+    super(raw);
+    this.tables = new Map(
+      datasourceTypesOf(deterministic).map((t) => [t.name, t]),
+    );
+    this.views = new Map(
+      authoredViewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+    this.expandedViews = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    this.datasourceNames = new Set(this.tables.keys());
+  }
+
+  from(): GenerateEntry[] {
+    return [...this.views.values()].map((view) => this.tests(view));
+  }
+
+  private tests(view: Type): GenerateEntry {
+    const isUnion = isUnionEnum(view);
+    const cls = this.casing.convertTypes(view.name);
+    const members = isUnion
+      ? (view.union ?? []).map((name) => ({
+          acceptsMemberTest: this.casing.fnIdent(`accepts_${name}_member`),
+          memberExpr: `${cls}::${this.casing.convertTypes(name)}(${viewExpr(name, this, new Set([view.name]))})`,
+        }))
+      : [];
+    const fields = isUnion ? [] : shapedToks(view, this, new Set([view.name]));
+    const fixture =
+      fields.length === 0
+        ? `${cls} {}`
+        : `${cls} {\n${fields.map((f) => `            ${f.ident}: ${f.sampleExpr},`).join("\n")}\n        }`;
+    const src = this.imports.view(view.name);
+    return content(
+      this.imports.test(src, view.name),
+      fill(typeTestTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        structName: cls,
+        fileBase: this.casing.fileBase(view.name),
+        isShaped: !isUnion,
+        isUnion,
+        needsHashMap: fields.some((f) => f.sampleExpr.includes("HashMap")),
+        fixture,
+        fields,
+        members,
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(
+    ctx.settings,
+    await DeterministicParser(ctx.reader).parse(ctx.settings),
+  ).from();
+};

package/node_modules/@deterministic-code/rust-generators/src/generate-view-types.ts

@@ -0,0 +1,168 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  fieldTypeOf,
+  tableKind,
+  viewTypesOf,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  emitViewFields,
+  fieldRefKind,
+  isAlias,
+  isUnionEnum,
+  wrapsInheritedDatasource,
+} from "./common/view-shape.ts";
+import {
+  DeterministicParser,
+  TYPES_YAML,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "./specification-parser.ts";
+import {
+  convertSpecType,
+  rustLanguageZero,
+  rustSpecDefaultExpr,
+} from "./deterministic-type-converter.ts";
+import { typeTmpl } from "./resources/view-types.ts";
+import { Emit } from "./emit.ts";
+import { typesNeedingDefault } from "./struct-default.ts";
+
+class Generator extends Emit {
+  private readonly typesByName: Map<string, Type>;
+  private readonly datasourceNames: Set<string>;
+  private readonly expandedByName: Map<string, Type>;
+
+  constructor(raw: Record<string, string>, deterministic: IDeterministic) {
+    super(raw);
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    this.datasourceNames = new Set(
+      datasourceTypesOf(deterministic).map((t) => t.name),
+    );
+    this.expandedByName = new Map(
+      viewTypesOf(deterministic).map((v) => [v.name, v]),
+    );
+  }
+
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    const needingDefault = typesNeedingDefault(deterministic);
+    return authoredViewTypesOf(deterministic).map((view) =>
+      this.view(view, this.expandedByName.get(view.name), needingDefault),
+    );
+  }
+
+  private rustPart(field: TypeField): string {
+    const refKind = fieldRefKind(field, this.typesByName);
+    return refKind === "primitive"
+      ? convertSpecType(field.base)
+      : refKind === "datasource"
+        ? this.imports.datasourceQual(field.base)
+        : this.imports.viewQual(field.base);
+  }
+
+  private rustTypeFor(field: TypeField): string {
+    const dict = dictionaryOfField(field, this.typesByName);
+    const entry = dict === undefined ? undefined : dictionaryEntryFields(dict);
+    let base: string;
+    if (entry !== undefined) {
+      base = `HashMap<${this.rustPart(entry.key)}, ${this.rustPart(entry.value)}>`;
+    } else {
+      base = this.rustPart(field);
+      if (field.isArray) base = `Vec<${base}>`;
+    }
+    return field.isNullable ? `Option<${base}>` : base;
+  }
+
+  private fieldToken(field: TypeField) {
+    const rustType = this.rustTypeFor(field);
+    const specExpr =
+      field.kind === "primitive"
+        ? rustSpecDefaultExpr(fieldTypeOf(field, this.typesByName), field)
+        : undefined;
+    return {
+      ident: this.casing.convertFields(field.name),
+      rustType,
+      defaultExpr: specExpr ?? rustLanguageZero(rustType),
+    };
+  }
+
+  private structFields(view: Type, expanded: Type | undefined) {
+    const fields = emitViewFields(view, expanded, this.datasourceNames).map(
+      (f) => this.fieldToken(f),
+    );
+    const synthetic = (ident: string, rustType: string) => ({
+      ident,
+      rustType,
+      defaultExpr: rustLanguageZero(rustType),
+    });
+    if (isAlias(view) && fields.length > 0) {
+      return [
+        synthetic("base", this.imports.datasourceQual(view.name)),
+        ...fields,
+      ];
+    }
+    if (
+      view.inherits !== undefined &&
+      wrapsInheritedDatasource(view, this.datasourceNames)
+    ) {
+      return [
+        synthetic("base", this.imports.datasourceQual(view.inherits)),
+        ...fields,
+      ];
+    }
+    return fields;
+  }
+
+  private view(
+    view: Type,
+    expanded: Type | undefined,
+    needingDefault: Set<string>,
+  ): GenerateEntry {
+    const structName = this.casing.convertTypes(view.name);
+    const isUnion = isUnionEnum(view);
+    const members = (view.union ?? []).map((name) => ({
+      variant: this.casing.convertTypes(name),
+      memberType: this.imports.viewQual(name),
+    }));
+    const fields = isUnion ? [] : this.structFields(view, expanded);
+    const alias = !isUnion && isAlias(view) && fields.length === 0;
+    const isStruct = !alias && !isUnion;
+    return content(
+      this.imports.view(view.name),
+      fill(typeTmpl, {
+        schemaVersion: this.settings.schemaVersion,
+        simpleDoc: this.settings.simpleDoc,
+        descriptionDoc: this.settings.descriptionDoc,
+        structName,
+        datasourceType: tableKind(view),
+        target: isUnion ? "UnionView" : "ShapedView",
+        fieldCount: String(isStruct ? fields.length : 0),
+        isAlias: alias,
+        aliasType: isAlias(view) ? this.imports.datasourceQual(view.name) : "",
+        isUnion,
+        isStruct,
+        implDefault: isStruct && needingDefault.has(view.name),
+        needsHashMap: fields.some((f) => f.rustType.includes("HashMap<")),
+        members,
+        fields,
+      }),
+    );
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  const deterministic = await DeterministicParser(ctx.reader).parse(
+    ctx.settings,
+  );
+  return new Generator(ctx.settings, deterministic).from(deterministic);
+};