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

package/node_modules/@deterministic-code/typescript-generators/dist/emit-shaped-types.js

@@ -0,0 +1,353 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  authoredViewTypesOf,
+  datasourceTypesOf,
+  dictionaryEntryFields,
+  dictionaryOfField,
+  fieldTypeOf,
+  isCollectionField,
+  persistedColumnFields,
+  tableKind,
+  TYPES_YAML,
+  typeHasTag,
+  typesWithTag,
+  viewTypesOf
+} from "@deterministic-code/generators-common/spec-types";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { nativeDefaultExpr, toNative } from "./deterministic-type-converter.js";
+import { fieldRefKind, fieldsBeyondParent, isAlias } from "./common/view-shape.js";
+import { bag, Emit } from "./emit.js";
+import {
+  indexTmpl as defaultIndexTmpl,
+  typeTmpl as defaultTypeTmpl
+} from "./resources/shaped-types.js";
+const BUILTIN_PARENTS = /* @__PURE__ */ new Set(["set", "dictionary", "file"]);
+const groupImports = (entries) => {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const isValue = e.isValue === true;
+    const key = `${e.fromPath}\0${isValue}`;
+    const group = byPath.get(key) ?? { fromPath: e.fromPath, isValue, tokens: [] };
+    group.tokens.push(e.alias ? `${e.original} as ${e.alias}` : e.original);
+    byPath.set(key, group);
+  }
+  return [...byPath.values()].map((group) => ({
+    fromPath: group.fromPath,
+    isValue: group.isValue,
+    names: [...new Set(group.tokens)].sort().join(", ")
+  })).sort((a, b) => a.fromPath.localeCompare(b.fromPath));
+};
+const classKey = (kind, name) => `${kind}:${name}`;
+class Generator extends Emit {
+  kind;
+  referenceBackendType;
+  templates;
+  typesByName = /* @__PURE__ */ new Map();
+  classSet = /* @__PURE__ */ new Set();
+  constructor(raw, mode) {
+    super(raw, mode.basePath ?? ".", mode.datasourceBasePath ?? ".");
+    this.kind = mode.kind;
+    this.referenceBackendType = mode.kind === "view" && (mode.referenceBackendType ?? true);
+    this.templates = mode.templates ?? {
+      typeTmpl: defaultTypeTmpl,
+      indexTmpl: defaultIndexTmpl
+    };
+  }
+  from(deterministic) {
+    this.typesByName = new Map(
+      deterministic.expandedTypes.map((t) => [t.name, t])
+    );
+    this.classSet = this.computeClassSet(deterministic);
+    const authored = this.kind === "datasource" ? typesWithTag(deterministic.types, "datasource_type") : authoredViewTypesOf(deterministic);
+    const expandedByName = new Map(
+      (this.kind === "datasource" ? datasourceTypesOf(deterministic) : viewTypesOf(deterministic)).map((t) => [t.name, t])
+    );
+    const entries = authored.map((t) => this.type(t, expandedByName.get(t.name)));
+    const index = this.imports.index(this.file(authored[0]?.name ?? "index"));
+    if (index && this.settings.createIndex) {
+      entries.push(this.index(authored, index));
+    }
+    return entries;
+  }
+  file(name) {
+    return this.kind === "datasource" ? this.imports.datasource(name) : this.imports.view(name);
+  }
+  rel(name) {
+    return this.kind === "datasource" ? this.imports.datasourceRel(name) : this.imports.viewRel(name);
+  }
+  relKey(to) {
+    if (to.kind === "view") return this.imports.viewRel(to.entity);
+    return this.kind === "datasource" ? this.imports.datasourceRel(to.entity) : this.datasourceImports.datasourceRel(to.entity);
+  }
+  typeImport(from, to) {
+    const dest = to.kind === "view" ? this.imports.viewRel(to.entity) : this.kind === "datasource" ? this.imports.datasourceRel(to.entity) : this.datasourceImports.datasourceRel(to.entity);
+    return this.imports.spec(this.rel(from), dest);
+  }
+  collectImports(type, expanded, flatten, isClass) {
+    const self = type.name;
+    const entries = [];
+    const seen = /* @__PURE__ */ new Set();
+    const aliasByClass = /* @__PURE__ */ new Map();
+    const add = (original, alias, fromPath, isValue) => {
+      const key = `${fromPath}::${original}::${alias ?? ""}::${isValue}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      entries.push({ original, alias, fromPath, isValue });
+    };
+    for (const { entity, kind } of this.refs(type, expanded, flatten)) {
+      if (entity === self && (this.kind === "datasource" || kind === "view")) {
+        continue;
+      }
+      const typeName = this.casing.convertTypes(entity);
+      const alias = this.kind === "view" && this.referenceBackendType && kind === "datasource" && entity === self ? this.casing.baseTypeName(entity) : void 0;
+      if (alias !== void 0) aliasByClass.set(entity, alias);
+      const isValue = isClass && this.classSet.has(classKey(kind, entity)) && type.inherits === entity;
+      add(
+        typeName,
+        alias,
+        this.typeImport(type.name, { entity, kind }),
+        isValue
+      );
+    }
+    return { imports: groupImports(entries), aliasByClass };
+  }
+  refs(type, expanded, flatten = false) {
+    if (this.kind === "datasource") {
+      return !flatten && this.extendsType(type, /* @__PURE__ */ new Map()) !== void 0 && type.inherits !== void 0 && !BUILTIN_PARENTS.has(type.inherits) ? [{ entity: type.inherits, kind: "datasource" }] : [];
+    }
+    const refs = [];
+    const parentName = isAlias(type) ? type.name : type.inherits;
+    const parentType = parentName === void 0 ? void 0 : this.typesByName.get(parentName);
+    if (!flatten && this.referenceBackendType && parentName !== void 0 && (isAlias(type) || !BUILTIN_PARENTS.has(parentName)) && (isAlias(type) || parentType !== void 0 && typeHasTag(parentType, "datasource_type"))) {
+      refs.push({ entity: parentName, kind: "datasource" });
+    }
+    for (const f of this.emitFields(type, expanded, flatten)) {
+      const mapped = dictionaryOfField(f, this.typesByName);
+      const entry = mapped === void 0 ? void 0 : dictionaryEntryFields(mapped);
+      const target = entry?.value ?? f;
+      const refKind = fieldRefKind(target, this.typesByName);
+      if (refKind === "primitive") continue;
+      refs.push({
+        entity: target.base,
+        kind: !this.referenceBackendType && refKind === "datasource" ? "view" : refKind
+      });
+    }
+    return refs;
+  }
+  partTs(field, aliasByClass) {
+    const refKind = fieldRefKind(field, this.typesByName);
+    return refKind === "primitive" ? toNative(field.base) : aliasByClass.get(field.base) ?? this.casing.convertTypes(field.base);
+  }
+  fieldTs(field, aliasByClass) {
+    if (this.kind === "datasource") {
+      return toNative(fieldTypeOf(field, this.typesByName));
+    }
+    const dict = dictionaryOfField(field, this.typesByName);
+    const entry = dict === void 0 ? void 0 : dictionaryEntryFields(dict);
+    if (entry !== void 0) {
+      return `Dictionary<${this.partTs(entry.key, aliasByClass)}, ${this.partTs(entry.value, aliasByClass)}>`;
+    }
+    const base = this.partTs(field, aliasByClass);
+    return field.isArray ? `${base}[]` : base;
+  }
+  extendsType(type, aliasByClass, kind = this.kind, referenceBackendType = this.referenceBackendType) {
+    if (kind === "view" && !referenceBackendType) return void 0;
+    const parentName = kind === "view" && isAlias(type) ? type.name : type.inherits;
+    if (parentName === void 0 || !(kind === "view" && isAlias(type)) && BUILTIN_PARENTS.has(parentName)) {
+      return void 0;
+    }
+    if (kind === "view") {
+      const parentType = this.typesByName.get(parentName);
+      if (parentType !== void 0 && !typeHasTag(parentType, "datasource_type") && !isAlias(type)) {
+        return void 0;
+      }
+    }
+    if (kind === "datasource") {
+      const parentType = this.typesByName.get(parentName);
+      if (parentType === void 0 || !typeHasTag(parentType, "datasource_type")) {
+        return void 0;
+      }
+    }
+    const parent = aliasByClass.get(parentName) ?? this.casing.convertTypes(parentName);
+    const omitKeys = type.removeFields ?? [];
+    if (omitKeys.length === 0) return parent;
+    return `Omit<${parent}, ${omitKeys.map((k) => JSON.stringify(this.casing.convertFields(k))).join(" | ")}>`;
+  }
+  remainingFields(type, expanded) {
+    const fields = expanded?.fields ?? type.fields;
+    return this.kind === "datasource" ? persistedColumnFields({ ...type, fields }, this.typesByName) : fields;
+  }
+  emitFields(type, expanded, flatten = false, kind = this.kind, referenceBackendType = this.referenceBackendType) {
+    if (flatten) return this.remainingFields(type, expanded);
+    if (kind === "view" && referenceBackendType && isAlias(type)) {
+      return (expanded?.fields ?? type.fields).filter(isCollectionField);
+    }
+    if (this.extendsType(type, /* @__PURE__ */ new Map(), kind, referenceBackendType) !== void 0) {
+      if (kind === "datasource") {
+        return persistedColumnFields(type, this.typesByName);
+      }
+      const parentName = isAlias(type) ? type.name : type.inherits;
+      const parent = parentName === void 0 ? void 0 : this.typesByName.get(parentName);
+      return fieldsBeyondParent(expanded?.fields ?? type.fields, parent);
+    }
+    const fields = expanded?.fields ?? type.fields;
+    return kind === "datasource" ? persistedColumnFields(
+      { ...type, fields },
+      this.typesByName
+    ) : fields;
+  }
+  hasNonZeroDefault(type, expanded, kind, referenceBackendType) {
+    return this.emitFields(
+      type,
+      expanded,
+      false,
+      kind,
+      referenceBackendType
+    ).some(
+      (field) => field.kind === "primitive" && nativeDefaultExpr(fieldTypeOf(field, this.typesByName), field) !== void 0
+    );
+  }
+  namedParent(type, kind, referenceBackendType) {
+    const rendered = this.extendsType(
+      type,
+      /* @__PURE__ */ new Map(),
+      kind,
+      referenceBackendType
+    );
+    if (rendered === void 0 || rendered.startsWith("Omit<")) return void 0;
+    if (kind === "datasource") {
+      return type.inherits === void 0 ? void 0 : { entity: type.inherits, kind: "datasource" };
+    }
+    const parentName = isAlias(type) ? type.name : type.inherits;
+    return parentName === void 0 ? void 0 : { entity: parentName, kind: "datasource" };
+  }
+  computeClassSet(deterministic) {
+    const expandedDatasource = new Map(
+      datasourceTypesOf(deterministic).map((type) => [type.name, type])
+    );
+    const expandedViews = new Map(
+      viewTypesOf(deterministic).map((type) => [type.name, type])
+    );
+    const parents = /* @__PURE__ */ new Map();
+    const seeds = /* @__PURE__ */ new Set();
+    const consider = (type, expanded, kind) => {
+      if (type.kind === "union") return;
+      if (kind === "view" && isAlias(type)) return;
+      const key = classKey(kind, type.name);
+      if (this.hasNonZeroDefault(type, expanded, kind, true)) seeds.add(key);
+      const parent = this.namedParent(type, kind, true);
+      if (parent !== void 0) parents.set(key, parent);
+    };
+    for (const type of typesWithTag(deterministic.types, "datasource_type")) {
+      consider(type, expandedDatasource.get(type.name), "datasource");
+    }
+    for (const type of authoredViewTypesOf(deterministic)) {
+      consider(type, expandedViews.get(type.name), "view");
+    }
+    const classes = new Set(seeds);
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const key of [...classes]) {
+        const parent = parents.get(key);
+        if (parent === void 0) continue;
+        const parentKey = classKey(parent.kind, parent.entity);
+        if (classes.has(parentKey)) continue;
+        classes.add(parentKey);
+        grew = true;
+      }
+    }
+    return classes;
+  }
+  type(type, expanded) {
+    const { schemaVersion, simpleDoc, descriptionDoc } = this.settings;
+    const className = this.casing.convertTypes(type.name);
+    const isClass = this.classSet.has(classKey(this.kind, type.name));
+    const parentProbe = this.extendsType(type, /* @__PURE__ */ new Map());
+    const flatten = isClass && parentProbe !== void 0 && parentProbe.startsWith("Omit<");
+    const { imports, aliasByClass } = this.collectImports(
+      type,
+      expanded,
+      flatten,
+      isClass
+    );
+    const parent = flatten ? void 0 : this.extendsType(type, aliasByClass);
+    const fields = this.emitFields(type, expanded, flatten);
+    const fieldTokens = fields.map((f) => {
+      const initializer = f.kind === "primitive" ? nativeDefaultExpr(fieldTypeOf(f, this.typesByName), f) : void 0;
+      return {
+        ident: this.casing.fieldIdent(f.name),
+        tsType: this.fieldTs(f, aliasByClass),
+        nullable: f.isNullable,
+        hasInitializer: isClass && initializer !== void 0,
+        initializer: initializer ?? "",
+        definite: isClass && initializer === void 0
+      };
+    });
+    const refs = this.refs(type, expanded, flatten);
+    return content(
+      this.file(type.name),
+      fill(this.templates.typeTmpl, {
+        schemaVersion,
+        imports,
+        hasImports: imports.length > 0,
+        simpleDoc,
+        descriptionDoc,
+        docNoun: this.kind === "datasource" ? "Type" : "View",
+        className,
+        datasourceType: tableKind(type),
+        target: this.kind === "datasource" ? "ShapedType" : "ShapedView",
+        fieldCount: String(fieldTokens.length),
+        isUnion: false,
+        isShaped: true,
+        isClass,
+        hasExtends: parent !== void 0,
+        extendsType: parent ?? "",
+        hasFields: fieldTokens.length > 0,
+        hasDictionary: fields.some((f) => f.isMap === true),
+        fields: fieldTokens,
+        unionMembers: ""
+      }),
+      bag({
+        module: this.rel(type.name),
+        exports: className,
+        imports: refs.map((r) => this.relKey(r)),
+        uses: refs.map((r) => this.casing.convertTypes(r.entity))
+      })
+    );
+  }
+  index(types, index) {
+    const modules = types.map((t) => this.rel(t.name));
+    const exports = types.map((t) => this.casing.convertTypes(t.name)).join(", ");
+    return content(
+      index,
+      fill(this.templates.indexTmpl, {
+        types: types.map((t) => ({
+          className: this.casing.convertTypes(t.name),
+          fileBase: this.casing.fileBase(t.name),
+          isClass: this.classSet.has(classKey(this.kind, t.name))
+        }))
+      }),
+      bag({
+        module: this.rel(types[0]?.name ?? "index").replace(/[^/]+$/, "index.ts"),
+        exports,
+        imports: modules,
+        uses: exports
+      })
+    );
+  }
+}
+const generateShapedTypes = async (ctx, mode) => {
+  await ctx.reader.read(TYPES_YAML);
+  return new Generator(ctx.settings, mode).from(
+    await DeterministicParser(ctx.reader).parse(ctx.settings)
+  );
+};
+const generateViewTypes = async (ctx, mode = {}) => generateShapedTypes(ctx, { kind: "view", ...mode });
+export {
+  generateShapedTypes,
+  generateViewTypes
+};

package/node_modules/@deterministic-code/typescript-generators/dist/emit.js

@@ -0,0 +1,43 @@
+import {
+  fromSettings
+} from "@deterministic-code/generators-common/settings";
+import { createCasing } from "./common/default-casing.js";
+import {
+  createImportGenerator
+} from "./import-generator.js";
+const joinList = (value) => {
+  if (value === void 0) return void 0;
+  const parts = (typeof value === "string" ? [value] : [...value]).flatMap((part) => part.split(",")).map((part) => part.trim()).filter((part) => part.length > 0);
+  return parts.length === 0 ? void 0 : parts.join(", ");
+};
+const bag = (attrs) => {
+  const out = { module: attrs.module };
+  const exports = joinList(attrs.exports);
+  const imports = joinList(attrs.imports);
+  const uses = joinList(attrs.uses);
+  if (exports !== void 0) out.exports = exports;
+  if (imports !== void 0) out.imports = imports;
+  if (uses !== void 0) out.uses = uses;
+  return out;
+};
+const customRelKey = (emitPath, layer) => emitPath.startsWith("../") ? `${layer}/${emitPath.slice(3)}` : emitPath;
+class Emit {
+  settings;
+  casing;
+  imports;
+  datasourceImports;
+  constructor(raw, basePath = ".", datasourceBasePath) {
+    this.settings = fromSettings(raw);
+    this.casing = createCasing(raw);
+    this.imports = createImportGenerator(basePath, raw);
+    this.datasourceImports = createImportGenerator(
+      datasourceBasePath ?? ".",
+      raw
+    );
+  }
+}
+export {
+  Emit,
+  bag,
+  customRelKey
+};

package/node_modules/@deterministic-code/typescript-generators/dist/frontend-bindings-routes.js

@@ -0,0 +1,4 @@
+const resolvesToSelf = (schema) => schema === "self" || typeof schema === "string" && schema.startsWith("id:");
+export {
+  resolvesToSelf
+};

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

@@ -0,0 +1,105 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content, patch } from "@deterministic-code/generators-common/generate-entry";
+import {
+  appBootTestTs,
+  appTs,
+  dockerComposeYml,
+  dockerfile,
+  entrypointSh,
+  envFile,
+  gitignore,
+  healthTestTs,
+  packageJson,
+  serverTs,
+  tsconfigJson,
+  vitestConfigTs
+} from "./resources/backend-app.js";
+import {
+  minimalAppTs,
+  minimalHealthTestTs,
+  minimalPackageJson,
+  minimalServerTs,
+  minimalTsconfigJson
+} from "./resources/backend-app-minimal.js";
+import { Emit } from "./emit.js";
+const DEFAULT_APP_NAME = "generated-app";
+const DEFAULT_COMPLEXITY = "deterministic";
+const complexityOf = (settings) => {
+  const raw = settings.app_generate_complexity;
+  if (raw === void 0 || raw === "") return DEFAULT_COMPLEXITY;
+  if (raw === "minimal" || raw === "deterministic") return raw;
+  throw new Error(
+    `settings.app_generate_complexity must be "minimal" or "deterministic", got ${JSON.stringify(raw)}`
+  );
+};
+class Generator extends Emit {
+  from(appName, complexity) {
+    return complexity === "minimal" ? this.minimal(appName) : this.deterministic(appName);
+  }
+  tokens(appName) {
+    const appFile = this.imports.app();
+    const serverFile = this.imports.server();
+    return {
+      appName,
+      appFnName: this.casing.appFnName(),
+      appFile,
+      appFileBase: this.casing.fileBase("app"),
+      serverFile,
+      serverFileBase: this.casing.fileBase("server"),
+      healthTestFile: this.imports.appTest("health"),
+      appBootTestFile: this.imports.appTest("app_boot"),
+      statusField: this.casing.convertFields("status"),
+      includeJson: JSON.stringify([
+        appFile,
+        serverFile,
+        ...this.imports.tsconfigIncludes(),
+        "perf-server.ts"
+      ])
+    };
+  }
+  minimal(appName) {
+    const named = this.tokens(appName);
+    return [
+      content(named.appFile, fill(minimalAppTs, named)),
+      content(named.serverFile, fill(minimalServerTs, named)),
+      content("package.json", fill(minimalPackageJson, named)),
+      content("tsconfig.json", fill(minimalTsconfigJson, named)),
+      content(named.healthTestFile, fill(minimalHealthTestTs, named))
+    ];
+  }
+  deterministic(appName) {
+    const named = this.tokens(appName);
+    const owned = /* @__PURE__ */ new Set([
+      named.serverFile,
+      "tsconfig.json",
+      named.healthTestFile
+    ]);
+    return [
+      ...this.minimal(appName).filter((e) => !owned.has(e.filename)),
+      patch(named.appFile, fill(appTs, named)),
+      content(named.serverFile, fill(serverTs, named)),
+      patch("package.json", fill(packageJson, named)),
+      content("tsconfig.json", fill(tsconfigJson, named)),
+      patch("Dockerfile", fill(dockerfile, named)),
+      patch(".dockerignore", "node_modules"),
+      patch("scripts/entrypoint.sh", entrypointSh),
+      patch("docker-compose.yml", dockerComposeYml),
+      patch(".env", envFile),
+      patch(".env.example", envFile),
+      patch(".gitignore", gitignore),
+      content("vitest.config.ts", vitestConfigTs),
+      content(named.healthTestFile, fill(healthTestTs, named)),
+      content(named.appBootTestFile, fill(appBootTestTs, named))
+    ];
+  }
+}
+const generate = async (ctx) => {
+  const appName = ctx.settings.application_name || DEFAULT_APP_NAME;
+  return new Generator(ctx.settings).from(
+    appName,
+    complexityOf(ctx.settings)
+  );
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-client-bindings-live-tests.js

@@ -0,0 +1,28 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { loadClientBindingsIr } from "./client-bindings-ir.js";
+import { clientBindingLiveTestPath } from "./client-binding-transport.js";
+import {
+  httpEntityTmpl,
+  tanstackEntityTmpl
+} from "./resources/client-bindings-live-tests.js";
+const generate = async (ctx) => {
+  const ir = await loadClientBindingsIr(ctx);
+  return ir.entities.flatMap((entity) => [
+    content(
+      clientBindingLiveTestPath("fetch", entity.fileBase),
+      fill(httpEntityTmpl, entity)
+    ),
+    content(
+      clientBindingLiveTestPath("axios", entity.fileBase),
+      fill(httpEntityTmpl, entity)
+    ),
+    content(
+      clientBindingLiveTestPath("tanstack", entity.fileBase),
+      fill(tanstackEntityTmpl, entity)
+    )
+  ]);
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-client-bindings-mock-tests.js

@@ -0,0 +1,28 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { loadClientBindingsIr } from "./client-bindings-ir.js";
+import { clientBindingMockTestPath } from "./client-binding-transport.js";
+import {
+  httpEntityTmpl,
+  tanstackEntityTmpl
+} from "./resources/client-bindings-mock-tests.js";
+const generate = async (ctx) => {
+  const ir = await loadClientBindingsIr(ctx);
+  return ir.entities.flatMap((entity) => [
+    content(
+      clientBindingMockTestPath("fetch", entity.fileBase),
+      fill(httpEntityTmpl, entity)
+    ),
+    content(
+      clientBindingMockTestPath("axios", entity.fileBase),
+      fill(httpEntityTmpl, entity)
+    ),
+    content(
+      clientBindingMockTestPath("tanstack", entity.fileBase),
+      fill(tanstackEntityTmpl, entity)
+    )
+  ]);
+};
+export {
+  generate
+};

package/node_modules/@deterministic-code/typescript-generators/dist/generate-client-bindings.js

@@ -0,0 +1,55 @@
+import { fill } from "@deterministic-code/generators-common/fill";
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import { fromSettings } from "@deterministic-code/generators-common/settings";
+import { loadClientBindingsIr } from "./client-bindings-ir.js";
+import {
+  clientBindingFilePath,
+  clientBindingHttpPath,
+  clientBindingIndexPath,
+  clientBindingRootIndex
+} from "./client-binding-transport.js";
+import {
+  axiosHttpTmpl,
+  entityTmpl,
+  fetchHttpTmpl,
+  rootIndexTmpl,
+  tanstackIndexTmpl,
+  tanstackTmpl,
+  transportIndexTmpl
+} from "./resources/client-bindings.js";
+const generate = async (ctx) => {
+  const ir = await loadClientBindingsIr(ctx);
+  const entries = [
+    content(clientBindingHttpPath("fetch"), fetchHttpTmpl),
+    content(clientBindingHttpPath("axios"), axiosHttpTmpl),
+    ...ir.entities.flatMap((entity) => [
+      content(
+        clientBindingFilePath("fetch", entity.fileBase),
+        fill(entityTmpl, entity)
+      ),
+      content(
+        clientBindingFilePath("axios", entity.fileBase),
+        fill(entityTmpl, entity)
+      ),
+      content(
+        clientBindingFilePath("tanstack", entity.fileBase),
+        fill(tanstackTmpl, entity)
+      )
+    ])
+  ];
+  if (!fromSettings(ctx.settings).createIndex) return entries;
+  const indexTokens = { entities: ir.entities, hasHttp: true };
+  entries.push(
+    content(clientBindingIndexPath("fetch"), fill(transportIndexTmpl, indexTokens)),
+    content(clientBindingIndexPath("axios"), fill(transportIndexTmpl, indexTokens)),
+    content(
+      clientBindingIndexPath("tanstack"),
+      fill(tanstackIndexTmpl, { entities: ir.entities })
+    ),
+    content(clientBindingRootIndex, rootIndexTmpl)
+  );
+  return entries;
+};
+export {
+  generate
+};