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

package/node_modules/@deterministic-code/typescript-generators/src/generate-datasource-types-tests.ts

@@ -0,0 +1,97 @@
+import { toNative } from "./deterministic-type-converter.ts";
+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,
+  fieldTypeOf,
+  persistedColumnFields,
+  TYPES_YAML,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  type IDeterministic,
+  type Type,
+  type TypeField,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { fieldSize } from "./common/view-shape.ts";
+import { typeTestTmpl } from "./resources/datasource-types-tests.ts";
+import {
+  fakeTestData,
+  fieldExpr,
+  preludeSource,
+  withFakerPackagePatch,
+} from "./common/fake-test-data.ts";
+import { bag, Emit } from "./emit.ts";
+
+const escapeTestName = (name: string): string =>
+  name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+
+const fieldTokens = (
+  field: TypeField,
+  fieldIdent: (name: string) => string,
+  typesByName: ReadonlyMap<string, Type>,
+) => {
+  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: IDeterministic): GenerateEntry[] {
+    const typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t]),
+    );
+    return datasourceTypesOf(deterministic).map((table) =>
+      this.tests(table, typesByName),
+    );
+  }
+
+  private tests(table: Type, typesByName: Map<string, Type>): GenerateEntry {
+    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,
+      }),
+    );
+  }
+}
+
+/** Returns attributed entries. Cross-lane type imports need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  await ctx.reader.read(TYPES_YAML);
+  return withFakerPackagePatch(
+    new Generator(ctx.settings).from(
+      await DeterministicParser(ctx.reader).parse(ctx.settings),
+    ),
+  );
+};

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

@@ -0,0 +1,13 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import { generateShapedTypes } from "./emit-shaped-types.ts";
+
+/** Self-checks references; keeps attributes for host `finalizeEntries` before write. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const entries = await generateShapedTypes(ctx, { kind: "datasource" });
+  verifyEntries(entries);
+  return entries;
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-frontend-app.ts

@@ -0,0 +1,180 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import * as angular from "./resources/frontend-app-angular.ts";
+import * as next from "./resources/frontend-app-next.ts";
+import * as svelte from "./resources/frontend-app-svelte.ts";
+import * as vite from "./resources/frontend-app.ts";
+import type { PackCasing } from "./common/default-casing.ts";
+import { Emit } from "./emit.ts";
+import type { TypeScriptImportGenerator } from "./import-generator.ts";
+import type { FrontendFramework } from "@deterministic-code/generators-common/settings";
+
+type FileSpec = {
+  filename: string;
+  tmpl: string;
+  kind: "content" | "patch";
+  section?: string;
+};
+
+const frameworks = (
+  imports: TypeScriptImportGenerator,
+  casing: PackCasing,
+): Record<
+  FrontendFramework,
+  { scaffold: FileSpec[]; fullStack: FileSpec[] }
+> => {
+  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" },
+      ] satisfies FileSpec[],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: vite.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND",
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: vite.dockerfile, kind: "content" },
+      ] satisfies FileSpec[],
+    },
+    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" },
+      ] satisfies FileSpec[],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: next.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND",
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: next.dockerfile, kind: "content" },
+      ] satisfies FileSpec[],
+    },
+    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" },
+      ] satisfies FileSpec[],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: svelte.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND",
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: svelte.dockerfile, kind: "content" },
+      ] satisfies FileSpec[],
+    },
+    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" },
+      ] satisfies FileSpec[],
+      fullStack: [
+        {
+          filename: "docker-compose.yml",
+          tmpl: angular.dockerComposeServiceYml,
+          kind: "patch",
+          section: "COMPOSE_SERVICE_FRONTEND",
+        },
+        { filename: imports.frontend("Dockerfile"), tmpl: angular.dockerfile, kind: "content" },
+      ] satisfies FileSpec[],
+    },
+  };
+};
+
+class Generator extends Emit {
+  from(): GenerateEntry[] {
+    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);
+    });
+  }
+}
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => new Generator(ctx.settings).from();

package/node_modules/@deterministic-code/typescript-generators/src/generate-frontend-types-tests.ts

@@ -0,0 +1,17 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { Emit } from "./emit.ts";
+import { generate as generateViewTypesTests } from "./generate-view-types-tests.ts";
+import { referencesBackend } from "./inline-inherited.ts";
+
+/** Returns attributed entries. Cross-lane type imports need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const referenceBackendType = referencesBackend(ctx.settings);
+  return generateViewTypesTests(
+    ctx,
+    new Emit(ctx.settings).imports.frontend("src/types"),
+    referenceBackendType,
+  );
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-frontend-types.ts

@@ -0,0 +1,23 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import { Emit } from "./emit.ts";
+import { generateViewTypes } from "./emit-shaped-types.ts";
+import { referencesBackend } from "./inline-inherited.ts";
+
+/** Self-checks when the lane is closed; backend-type refs need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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;
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-frontend-validators-tests.ts

@@ -0,0 +1,17 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { Emit } from "./emit.ts";
+import { generate as generateViewTypeValidatorsTests } from "./generate-view-type-validators-tests.ts";
+import { referencesBackend } from "./inline-inherited.ts";
+
+/** Returns attributed entries. Cross-lane validator imports need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  const referenceBackendType = referencesBackend(ctx.settings);
+  return generateViewTypeValidatorsTests(
+    ctx,
+    new Emit(ctx.settings).imports.frontend("src/validators"),
+    referenceBackendType,
+  );
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-frontend-validators.ts

@@ -0,0 +1,39 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import type { GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { verifyEntries } from "@deterministic-code/generators-common/reference-verifier";
+import { Emit } from "./emit.ts";
+import { generate as generateViewTypeValidators } from "./generate-view-type-validators.ts";
+import { referencesBackend } from "./inline-inherited.ts";
+import {
+  indexTmpl,
+  schemaInheritTmpl,
+  schemaStandaloneTmpl,
+  schemaUnionTmpl,
+  typeTmpl,
+} from "./resources/frontend-validators.ts";
+
+/** Self-checks when the lane is closed; backend-schema refs need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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;
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-perf-e2e-tests.ts

@@ -0,0 +1,9 @@
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { e2eTmpl } from "./resources/perf-e2e.ts";
+
+export const generate = async (
+  _ctx: GenerateContext,
+): Promise<GenerateEntry[]> => [
+  content("app.perf.client.test.ts", e2eTmpl),
+];

package/node_modules/@deterministic-code/typescript-generators/src/generate-perf-server.ts

@@ -0,0 +1,32 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
+import { content, patch, type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
+import { TYPES_YAML } from "@deterministic-code/generators-common/spec-types";
+import { createCasing } from "./common/default-casing.ts";
+import { serverTmpl, vitestPerfTmpl } from "./resources/perf-server.ts";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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" },
+      }),
+    ),
+  ];
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-routes-e2e-test.ts

@@ -0,0 +1,22 @@
+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 { ROUTES_YAML } from "@deterministic-code/generators-common/spec-types";
+import { createCasing } from "./common/default-casing.ts";
+import { e2eTmpl } from "./resources/routes-e2e.ts";
+
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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"),
+      }),
+    ),
+  ];
+};

package/node_modules/@deterministic-code/typescript-generators/src/generate-routes-tests.ts

@@ -0,0 +1,75 @@
+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 {
+  isReadonlyLookup,
+  ROUTES_YAML,
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser,
+  type IDeterministic,
+  type RouteCandidate,
+  type Type,
+} from "@deterministic-code/deterministic-generators-common/parser";
+import {
+  fakeTestData,
+  preludeSource,
+  withFakerPackagePatch,
+} from "./common/fake-test-data.ts";
+import { crudTmpl, readonlyTmpl } from "./resources/routes-tests.ts";
+import { isDictionaryCandidate } from "./common/dictionary-candidate.ts";
+import { bag, Emit } from "./emit.ts";
+
+class Generator extends Emit {
+  private readonly types: Type[];
+
+  constructor(raw: Record<string, string>, types: Type[]) {
+    super(raw);
+    this.types = types;
+  }
+
+  from(deterministic: IDeterministic): GenerateEntry[] {
+    return deterministic.routes.candidates
+      .filter((c) => !isDictionaryCandidate(c))
+      .map((c) => this.test(c));
+  }
+
+  private test(candidate: RouteCandidate): GenerateEntry {
+    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 !== undefined && isReadonlyLookup(table) ? readonlyTmpl : crudTmpl,
+      {
+        prelude: preludeSource(fakeTestData),
+        fnName,
+        routeImport,
+      },
+    );
+    return content(path, body, attrs);
+  }
+}
+
+/** Returns attributed entries. Cross-lane route imports need host `finalizeEntries`. */
+export const generate = async (
+  ctx: GenerateContext,
+): Promise<GenerateEntry[]> => {
+  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,
+    ),
+  );
+};