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

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes/readonly.ts.tmpl

@@ -0,0 +1,6 @@
+{{#simpleDoc}}/** Route {{fnName}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Route {{fnName}}.
+ * Datasource type: {{datasourceType}}.
+ */
+{{/descriptionDoc}}export function {{fnName}}() {}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-e2e/app.integration.test.ts.tmpl

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { once } from "node:events";
+import { createServer } from "node:http";
+import type { AddressInfo } from "node:net";
+import { {{appFnName}} } from "../{{appFileBase}}.js";
+
+describe("app routes e2e", () => {
+  it("serves GET /api/health", async () => {
+    const app = await {{appFnName}}();
+    const server = createServer(app);
+    server.listen(0);
+    await once(server, "listening");
+    try {
+      const { port } = server.address() as AddressInfo;
+      const res = await fetch(`http://127.0.0.1:${port}/api/health`);
+      expect(res.status).toBeLessThan(500);
+    } finally {
+      server.close();
+      await once(server, "close");
+    }
+  });
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/by-field-delete-list.ts.tmpl

@@ -0,0 +1,7 @@
+
+  it("DELETE {{mountPath}}/{{kebab}}/:value returns { count } for the non-unique case", async () => {
+    service.deleteBy.mockResolvedValueOnce(2);
+    const res = await request(app).delete("{{mountPath}}/{{kebab}}/x"){{&ifMatch}};
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ count: 2 });
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/by-field-delete-unique.ts.tmpl

@@ -0,0 +1,14 @@
+
+  it("DELETE {{mountPath}}/{{kebab}}/:value returns success when one row deleted", async () => {
+    service.deleteBy.mockResolvedValueOnce(1);
+    const res = await request(app).delete("{{mountPath}}/{{kebab}}/x"){{&ifMatch}};
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ success: true });
+    expect(service.deleteBy).toHaveBeenCalledWith([{ name: "{{byField}}", value: "x" }]);
+  });
+
+  it("DELETE {{mountPath}}/{{kebab}}/:value returns 404 when no row matches", async () => {
+    service.deleteBy.mockResolvedValueOnce(0);
+    const res = await request(app).delete("{{mountPath}}/{{kebab}}/missing"){{&ifMatch}};
+    expect(res.status).toBe(404);
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/by-field-get-list.ts.tmpl

@@ -0,0 +1,10 @@
+
+  it("GET {{mountPath}}/{{kebab}}/:value returns the array of matches", async () => {
+    service.findBy.mockResolvedValueOnce([
+      { id: 1, {{byField}}: "x" },
+      { id: 2, {{byField}}: "x" },
+    ]);
+    const res = await request(app).get("{{mountPath}}/{{kebab}}/x");
+    expect(res.status).toBe(200);
+    expect(service.findBy).toHaveBeenCalledWith([{ name: "{{byField}}", value: "x" }]);
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/by-field-get-unique.ts.tmpl

@@ -0,0 +1,22 @@
+
+  it("GET {{mountPath}}/{{kebab}}/:value returns the row when unique findBy matches", async () => {
+    service.findBy.mockResolvedValueOnce([{ id: 1, {{byField}}: "x" }]);
+    const res = await request(app).get("{{mountPath}}/{{kebab}}/x");
+    expect(res.status).toBe(200);
+    expect(service.findBy).toHaveBeenCalledWith([{ name: "{{byField}}", value: "x" }]);
+  });
+
+  it("GET {{mountPath}}/{{kebab}}/:value returns 404 when no row matches", async () => {
+    service.findBy.mockResolvedValueOnce([]);
+    const res = await request(app).get("{{mountPath}}/{{kebab}}/missing");
+    expect(res.status).toBe(404);
+  });
+
+  it("GET {{mountPath}}/{{kebab}}/:value returns 409 when multiple rows match a unique-byField route", async () => {
+    service.findBy.mockResolvedValueOnce([
+      { id: 1, {{byField}}: "x" },
+      { id: 2, {{byField}}: "x" },
+    ]);
+    const res = await request(app).get("{{mountPath}}/{{kebab}}/x");
+    expect(res.status).toBe(409);
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/by-field-put-list.ts.tmpl

@@ -0,0 +1,7 @@
+
+  it("PUT {{mountPath}}/{{kebab}}/:value returns { count } for the non-unique case", async () => {
+    service.updateBy.mockResolvedValueOnce(3);
+    const res = await request(app).put("{{mountPath}}/{{kebab}}/x"){{&ifMatch}}.send({});
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ count: 3 });
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/by-field-put-unique.ts.tmpl

@@ -0,0 +1,17 @@
+
+  it("PUT {{mountPath}}/{{kebab}}/:value updates the unique row", async () => {
+    service.updateBy.mockResolvedValueOnce(1);
+    service.findBy.mockResolvedValueOnce([{ id: 1, {{byField}}: "x" }]);
+    const res = await request(app).put("{{mountPath}}/{{kebab}}/x"){{&ifMatch}}.send({});
+    expect(res.status).toBe(200);
+    expect(service.updateBy).toHaveBeenCalledWith(
+      [{ name: "{{byField}}", value: "x" }],
+      {},
+    );
+  });
+
+  it("PUT {{mountPath}}/{{kebab}}/:value returns 404 when no row matches", async () => {
+    service.updateBy.mockResolvedValueOnce(0);
+    const res = await request(app).put("{{mountPath}}/{{kebab}}/missing"){{&ifMatch}}.send({});
+    expect(res.status).toBe(404);
+  });

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/crud.test.ts.tmpl

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+{{&prelude}}import { {{fnName}} } from "{{routeImport}}";
+
+describe("{{fnName}}", () => {
+  it("is defined", () => {
+    expect({{fnName}}).toBeTypeOf("function");
+  });
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/mock-factory.ts.tmpl

@@ -0,0 +1,16 @@
+function createMock(primaryKey?: any): any {
+  return {
+    primaryKey,
+    query: vi.fn().mockResolvedValue([]),
+    findAll: vi.fn().mockResolvedValue([]),
+    find: vi.fn().mockResolvedValue([]),
+    findById: vi.fn().mockResolvedValue(null),
+    findBy: vi.fn().mockResolvedValue([]),
+    create: vi.fn(async (data: unknown) => ({ id: 1, ...(data as object) })),
+    update: vi.fn(async (id: number, data: unknown) => ({ id, ...(data as object) })),
+    patch: vi.fn(async (id: number, data: unknown) => ({ id, ...(data as object) })),
+    delete: vi.fn().mockResolvedValue(true),
+    updateBy: vi.fn().mockResolvedValue(0),
+    deleteBy: vi.fn().mockResolvedValue(0),
+  };
+}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-routes-tests/readonly.test.ts.tmpl

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+{{&prelude}}import { {{fnName}} } from "{{routeImport}}";
+
+describe("{{fnName}}", () => {
+  it("is defined", () => {
+    expect({{fnName}}).toBeTypeOf("function");
+  });
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-service-integration-tests/generic.integration.test.ts.tmpl

@@ -0,0 +1,109 @@
+{{&prelude}}import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { copyFile, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  PrimaryKeyService,
+  SqliteDatasource,
+  SqliteStandardRepository,
+} from "@datasources/core";
+import { {{className}} } from "{{serviceImport}}";
+{{#parentImports}}import { {{className}} } from "{{importPath}}";
+{{/parentImports}}
+{{#typeImports}}import type { {{names}} } from "{{fromPath}}";
+{{/typeImports}}
+const TABLE_NAME = {{&tableNameJson}};
+const primaryKeys = new PrimaryKeyService([
+{{#pkEntries}}  { entityName: {{&entityNameJson}}, primaryKeyColumn: {{&columnJson}}, primaryKeyIdType: {{&pkIdTypeJson}} },
+{{/pkEntries}}]);
+
+describe("{{className}} (sqlite integration)", () => {
+  let tmpDir: string;
+  let dbPath: string;
+  let datasource: SqliteDatasource;
+  let service: {{className}};
+
+  beforeEach(async () => {
+    const prebuilt = process.env.npm_package_config_test_db;
+    if (!prebuilt) {
+      throw new Error(
+        "npm_package_config_test_db is unset — run via `npm test` so the pretest hook materializes the prebuilt sqlite via migrate-setup --and-up.",
+      );
+    }
+    tmpDir = await mkdtemp(join(tmpdir(), "{{entityName}}-itest-"));
+    dbPath = join(tmpDir, "test.db");
+    await copyFile(prebuilt, dbPath);
+    datasource = new SqliteDatasource({
+      dbPath,
+      pragmas: ["foreign_keys = ON"],
+    });
+    await datasource.open();
+    await datasource.query(`DELETE FROM ${TABLE_NAME}`);
+    const repository = new SqliteStandardRepository<{{rowTypeName}}>(
+      datasource,
+      TABLE_NAME,
+      { entityName: {{&entityNameJson}}, primaryKeys },
+    );
+    service = new {{className}}(repository{{#isUuidPk}}, { idType: "uuid" }{{/isUuidPk}});
+  });
+
+  afterEach(async () => {
+    await datasource.close();
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("findAll returns [] on an empty table", async () => {
+    expect(await service.findAll()).toEqual([]);
+  });
+{{#canCreate}}
+  it("create inserts a row and auto-populates id/created/updated", async () => {
+    const row = await service.create({}{{#createTypeName}} as {{createTypeName}}{{/createTypeName}});
+    const r = row as unknown as Record<string, unknown>;
+    expect(typeof r.id).toBe("{{idTsType}}");
+    expect(typeof r.created).toBe("string");
+    expect(typeof r.updated).toBe("string");
+  });
+{{/canCreate}}
+  it("findById returns null for a missing id", async () => {
+    expect(await service.findById({{&missingId}})).toBeNull();
+  });
+{{#canUpdate}}
+  it("update returns null for a missing id", async () => {
+    const result = await service.update({{&missingId}}, {});
+    expect(result).toBeNull();
+  });
+{{/canUpdate}}
+  it("delete returns false when the row does not exist", async () => {
+    expect(await service.delete({{&missingId}})).toBe(false);
+  });
+
+{{#hierarchy}}
+  it("create, update, and delete with parents", async () => {
+{{#chainServices}}    const {{varName}} = new {{className}}(
+      new SqliteStandardRepository<{{rowTypeName}}>(datasource, {{&tableNameJson}}, {
+        entityName: {{&entityNameJson}},
+        primaryKeys,
+      }){{#isUuidPk}}, { idType: "uuid" }{{/isUuidPk}},
+    );
+{{/chainServices}}
+{{#creates}}{{#isLookup}}    const {{varName}} = await {{serviceVar}}.findById({{&seedId}});
+    expect({{varName}}).not.toBeNull();
+    if ({{varName}} === null) {
+      throw new Error({{&missingSeedErrorJson}});
+    }
+{{/isLookup}}{{^isLookup}}    const {{varName}} = await {{serviceVar}}.create({
+{{#fields}}      {{ident}}: {{&expr}},
+{{/fields}}    }{{#createTypeName}} as {{createTypeName}}{{/createTypeName}});
+{{/isLookup}}{{/creates}}
+{{#updates}}    const {{updatedVarName}} = await {{serviceVar}}.update({{varName}}.{{pkIdent}}, {
+{{#fields}}      {{ident}}: {{&expr}},
+{{/fields}}    });
+    expect({{updatedVarName}}).not.toBeNull();
+{{/updates}}
+{{#deletes}}    expect(await {{serviceVar}}.delete({{varName}}.{{pkIdent}})).toBe(true);
+    expect(await {{serviceVar}}.findById({{varName}}.{{pkIdent}})).toBeNull();
+{{/deletes}}  });
+{{/hierarchy}}{{#missingLookupSeed}}
+  // Seed data does not exist for readonly-lookup "{{lookupName}}", so this test (and the remainder) cannot be written.
+{{/missingLookupSeed}}
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-service-tests/generic.test.ts.tmpl

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+{{&prelude}}import type { ICrudRepository } from "@datasources/core";
+import { {{className}} } from "{{importPath}}";
+
+type Repo = ICrudRepository<any>;
+
+function createMockRepository(): Repo {
+  return {
+    entityName: {{&entityNameJson}},
+    primaryKey: { fromRow: vi.fn() },
+    query: vi.fn().mockResolvedValue([]),
+    findAll: vi.fn().mockResolvedValue([]),
+    find: vi.fn().mockResolvedValue(null),
+    findBy: vi.fn().mockResolvedValue([]),
+    findIn: vi.fn().mockResolvedValue([]),
+    add: vi.fn(async (data: unknown) => ({ id: 1, ...(data as object) })),
+    update: vi.fn(async (id: number, data: unknown) => ({ id, ...(data as object) })),
+    delete: vi.fn().mockResolvedValue(true),
+  } as unknown as Repo;
+}
+
+describe("{{className}}", () => {
+  let repo: Repo;
+  let service: {{className}};
+
+  beforeEach(() => {
+    repo = createMockRepository();
+    service = new {{className}}(repo);
+  });
+
+  it("findAll delegates to the repository", async () => {
+    await service.findAll();
+    expect(repo.findAll).toHaveBeenCalledOnce();
+  });
+
+  it("findById forwards the id to repo.find", async () => {
+    const id = {{&idExpr}};
+    await service.findById(id);
+    expect(repo.find).toHaveBeenCalledWith(id);
+  });
+
+  it("create forwards the payload to repo.add", async () => {
+    const payload = { name: "example" } as any;
+    await service.create(payload);
+    expect(repo.add).toHaveBeenCalledWith(payload);
+  });
+
+  it("update forwards id + patch", async () => {
+    const id = {{&idExpr}};
+    const patch = { name: "renamed" } as any;
+    await service.update(id, patch);
+    expect(repo.update).toHaveBeenCalledWith(id, patch);
+  });
+
+  it("delete forwards the id", async () => {
+    const id = {{&idExpr}};
+    await service.delete(id);
+    expect(repo.delete).toHaveBeenCalledWith(id);
+  });
+
+  it("findBy translates a single NameValue to repo.findBy", async () => {
+    await service.findBy([{ name: "email", value: "a@b.c" }]);
+    expect(repo.findBy).toHaveBeenCalledWith("email", "a@b.c");
+  });
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-services/custom-stub.ts.tmpl

@@ -0,0 +1,30 @@
+{{#simpleDoc}}/** Service {{interfaceName}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{interfaceName}}.
+ * Datasource type: standard.
+ * Target: Custom.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}{{#hasMethods}}export interface {{interfaceName}} {
+{{#methods}}
+  {{name}}(..._args: unknown[]): Promise<unknown>;
+{{/methods}}
+}
+{{/hasMethods}}{{^hasMethods}}export interface {{interfaceName}} {}
+{{/hasMethods}}
+
+{{#simpleDoc}}/** Service {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{className}}.
+ * Datasource type: standard.
+ * Target: Custom.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}export class {{className}} implements {{interfaceName}} {
+  static readonly dependencies = [] as const;
+{{#methods}}
+  async {{name}}(..._args: unknown[]): Promise<unknown> {
+    return {};
+  }
+{{/methods}}
+}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-services/generic.ts.tmpl

@@ -0,0 +1,114 @@
+{{#typeImport}}import { {{typeName}} } from "{{typeImportPath}}";
+{{/typeImport}}{{#mutateImport}}import { {{mutateTypeName}} } from "{{mutateImportPath}}";
+{{/mutateImport}}import type { ICrudRepository } from "@datasources/core";
+
+type NameValue = { name: string; value: unknown };
+type Mutate = {{#mutateTypeName}}{{mutateTypeName}}{{/mutateTypeName}}{{^mutateTypeName}}Omit<{{typeName}}, {{pkOmit}}>{{/mutateTypeName}};
+
+{{#simpleDoc}}/** Service {{interfaceName}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{interfaceName}}.
+ * Datasource type: {{datasourceType}}.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}export type {{interfaceName}} = {{className}};
+
+{{#simpleDoc}}/** Service {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * Service {{className}}.
+ * Datasource type: {{datasourceType}}.
+ * Fields: 0.
+ */
+{{/descriptionDoc}}export class {{className}} {
+  readonly primaryKey;
+
+  constructor(
+    private readonly repository: ICrudRepository<{{typeName}}, {{idTsType}}>,
+  ) {
+    this.primaryKey = repository.primaryKey;
+  }
+
+  query(command: string, args: NameValue[]): Promise<{{typeName}}[]> {
+    return this.repository.query(command, args.map((a) => a.value));
+  }
+
+  findAll(): Promise<{{typeName}}[]> {
+    return this.repository.findAll();
+  }
+
+  create(data: Mutate): Promise<{{typeName}}> {
+    return this.repository.add(data);
+  }
+
+  find(query: string, args: NameValue[]): Promise<{{typeName}}[]> {
+    return this.repository.query(query, args.map((a) => a.value));
+  }
+
+  findById(id: {{idTsType}}): Promise<{{typeName}} | null> {
+    return this.repository.find(id);
+  }
+
+  findBy(whereArgs: NameValue[]): Promise<{{typeName}}[]> {
+    if (whereArgs.length === 0) return this.repository.findAll();
+    if (whereArgs.length === 1) {
+      return this.repository.findBy(whereArgs[0].name, whereArgs[0].value);
+    }
+    return this.repository.query(
+      whereArgs.map((a) => a.name).join(" AND "),
+      whereArgs.map((a) => a.value),
+    );
+  }
+
+  update(
+    id: {{idTsType}},
+    data: Partial<Mutate>,
+    opts?: { expectedUpdated?: string },
+  ): Promise<{{typeName}} | null> {
+    return opts === undefined
+      ? this.repository.update(id, data)
+      : this.repository.update(id, data, opts);
+  }
+
+  patch(
+    id: {{idTsType}},
+    data: Partial<Mutate>,
+    opts?: { expectedUpdated?: string },
+  ): Promise<{{typeName}} | null> {
+    return this.update(id, data, opts);
+  }
+
+  delete(id: {{idTsType}}, opts?: { expectedUpdated?: string }): Promise<boolean> {
+    return opts === undefined
+      ? this.repository.delete(id)
+      : this.repository.delete(id, opts);
+  }
+
+  async updateBy(
+    whereArgs: NameValue[],
+    data: Partial<Mutate>,
+  ): Promise<number> {
+    const rows = await this.findBy(whereArgs);
+    let count = 0;
+    for (const row of rows) {
+      const id = this.primaryKey.fromRow(row as Record<string, unknown>) as {{idTsType}};
+      if ((await this.repository.update(id, data)) !== null) count++;
+    }
+    return count;
+  }
+
+  async deleteBy(whereArgs: NameValue[]): Promise<number> {
+    const rows = await this.findBy(whereArgs);
+    let count = 0;
+    for (const row of rows) {
+      const id = this.primaryKey.fromRow(row as Record<string, unknown>) as {{idTsType}};
+      if (await this.repository.delete(id)) count++;
+    }
+    return count;
+  }
+{{#finders}}
+  async {{method}}({{param}}: {{paramType}}): Promise<{{typeName}} | null> {
+    const rows = await this.findBy([{ name: "{{field}}", value: {{param}} }]);
+    return rows[0] ?? null;
+  }
+{{/finders}}
+}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-services/index.ts.tmpl

@@ -0,0 +1,3 @@
+{{#types}}export { {{className}} } from "./{{fileBase}}";
+export type { {{interfaceName}} } from "./{{fileBase}}";
+{{/types}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-shaped-types/index.ts.tmpl

@@ -0,0 +1,3 @@
+{{#types}}{{#isClass}}export { {{className}} } from "./{{fileBase}}";
+{{/isClass}}{{^isClass}}export type { {{className}} } from "./{{fileBase}}";
+{{/isClass}}{{/types}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-shaped-types/type.ts.tmpl

@@ -0,0 +1,25 @@
+// schema-version: {{schemaVersion}}
+{{#imports}}import{{^isValue}} type{{/isValue}} { {{names}} } from "{{fromPath}}";
+{{/imports}}{{#hasImports}}
+{{/hasImports}}{{#simpleDoc}}/** {{docNoun}} {{className}}. */
+{{/simpleDoc}}{{#descriptionDoc}}/**
+ * {{docNoun}} {{className}}.
+ * Datasource type: {{datasourceType}}.
+ * Target: {{target}}.
+ * Fields: {{fieldCount}}.
+ */
+{{/descriptionDoc}}{{#hasDictionary}}type Dictionary<K extends PropertyKey, V> = Record<K, V>;
+{{/hasDictionary}}{{#isUnion}}export type {{className}} = {{unionMembers}};
+{{/isUnion}}{{#isShaped}}{{#isClass}}export class {{className}}{{#hasExtends}} extends {{extendsType}}{{/hasExtends}}{{#hasFields}} {
+{{#fields}}
+  {{ident}}{{#definite}}!{{/definite}}: {{tsType}}{{#nullable}} | null{{/nullable}}{{#hasInitializer}} = {{&initializer}}{{/hasInitializer}};
+{{/fields}}
+}
+{{/hasFields}}{{^hasFields}} {}
+{{/hasFields}}{{/isClass}}{{^isClass}}export interface {{className}}{{#hasExtends}} extends {{extendsType}}{{/hasExtends}}{{#hasFields}} {
+{{#fields}}
+  {{ident}}: {{tsType}}{{#nullable}} | null{{/nullable}};
+{{/fields}}
+}
+{{/hasFields}}{{^hasFields}} {}
+{{/hasFields}}{{/isClass}}{{/isShaped}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-type-validators/index.ts.tmpl

@@ -0,0 +1,5 @@
+{{#types}}export { {{exports}} } from "./{{fileBase}}";
+{{#withTypeAnnotation}}
+export type { {{validatedTypeName}} } from "./{{fileBase}}";
+{{/withTypeAnnotation}}
+{{/types}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-type-validators/schema-inherit.ts.tmpl

@@ -0,0 +1,5 @@
+export const {{schemaName}} = {{dsAlias}}{{#hasOmits}}.omit({ {{&omitObj}} }){{/hasOmits}}{{#partialId}}.partial({ id: true }){{/partialId}}{{#hasFields}}.extend({
+{{#fields}}
+  {{ident}}: {{&zodExpr}},
+{{/fields}}
+}){{/hasFields}};

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-type-validators/schema-standalone.ts.tmpl

@@ -0,0 +1,10 @@
+export const {{schemaName}} = {{#emptyObject}}z.object({}){{/emptyObject}}{{^emptyObject}}z.object({
+{{#fields}}
+  {{ident}}: {{&zodExpr}},
+{{/fields}}
+}){{/emptyObject}};
+{{#hasTrio}}
+export const {{createName}} = {{schemaName}};
+export const {{updateName}} = {{schemaName}};
+export const {{patchName}} = {{schemaName}}.partial();
+{{/hasTrio}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-type-validators/schema-union.ts.tmpl

@@ -0,0 +1,4 @@
+export const {{schemaName}} = z.union([
+{{#members}}  z.lazy(() => {{ident}}),
+{{/members}}
+]);

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-type-validators/type.ts.tmpl

@@ -0,0 +1,11 @@
+// schema-version: {{schemaVersion}}
+import { z } from "zod";
+{{#imports}}
+import { {{names}} } from "{{fromPath}}";
+{{/imports}}
+
+{{&schemaBody}}
+{{#withTypeAnnotation}}
+
+export type {{validatedTypeName}} = z.infer<typeof {{schemaName}}>;
+{{/withTypeAnnotation}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-type-validators-tests/type.test.ts.tmpl

@@ -0,0 +1,12 @@
+// schema-version: {{schemaVersion}}
+{{&prelude}}import { describe, it, expect } from "vitest";
+import { {{schemaName}} } from "{{schemaImport}}";
+
+describe("{{schemaName}} (view_types.{{viewName}})", () => {
+{{#cases}}
+  it("{{name}}", () => {
+    const value = {{&fixture}};
+    expect(() => {{schemaName}}.parse(value)).{{assertion}}();
+  });
+{{/cases}}
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-types-tests/field-tests.ts.tmpl

@@ -0,0 +1,26 @@
+  it("gets {{testName}}", () => {
+    const initial = {{&sampleExpr}};
+{{#isRoot}}
+    const value: {{className}} = { ...sample(), {{ident}}: initial };
+{{/isRoot}}
+{{^isRoot}}
+    const value: {{className}} = sample();
+    value{{&access}} = initial;
+{{/isRoot}}
+    expect(value{{&access}}).toEqual(initial);
+  });
+
+  it("sets {{testName}}", () => {
+    const value: {{className}} = sample();
+    const next = {{&nextExpr}};
+    value{{&access}} = next;
+    expect(value{{&access}}).toEqual(next);
+  });
+{{#nullable}}
+  it("allows setting {{testName}} to null", () => {
+    const value: {{className}} = sample();
+    value{{&access}} = null;
+    expect(value{{&access}}).toBeNull();
+  });
+{{/nullable}}
+{{&nestedTests}}

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-types-tests/type.test.ts.tmpl

@@ -0,0 +1,26 @@
+// schema-version: {{schemaVersion}}
+{{&prelude}}import { describe, it, expect } from "vitest";
+import type { {{className}} } from "{{typeImport}}";
+{{#isUnion}}
+{{#members}}
+import type { {{memberClass}} } from "{{memberImport}}";
+{{/members}}
+{{/isUnion}}
+
+describe("{{className}} field accessors (view_types.{{viewName}})", () => {
+{{#isShaped}}
+  const sample = (): {{className}} => ({{&fixture}});
+
+  it("constructs a sample", () => {
+    expect(sample()).toBeDefined();
+  });
+
+{{&fieldTests}}{{/isShaped}}{{#isUnion}}
+{{#members}}
+  it("accepts a {{name}} member", () => {
+    const value: {{className}} = {{&memberFixture}} as {{memberClass}};
+    expect(value).toBeDefined();
+  });
+{{/members}}
+{{/isUnion}}
+});

package/node_modules/@deterministic-code/typescript-generators/src/templates/create-view-types-tests/value.ts.tmpl

@@ -0,0 +1 @@
+{{#isArray}}[{{/isArray}}{{#isObject}}{ {{#nested}}{{ident}}: {{&value}}{{^last}}, {{/last}}{{/nested}} }{{/isObject}}{{#isPrimitive}}{{&expr}}{{/isPrimitive}}{{#isArray}}]{{/isArray}}

package/node_modules/@deterministic-code/typescript-generators/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "nodenext", "moduleResolution": "nodenext", "target": "ES2022",
+    "lib": ["ES2022"], "types": ["node"], "declaration": true, "outDir": "dist",
+    "rootDir": "src", "allowImportingTsExtensions": true, "rewriteRelativeImportExtensions": true,
+    "resolveJsonModule": true, "skipLibCheck": true, "strict": true, "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "src/templates/**"]
+}