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

package/bin/datasources.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/main.js";

package/dist/catalog.js

@@ -0,0 +1,60 @@
+const providers = [
+  "json",
+  "memory",
+  "sqlite",
+  "xml",
+  "yaml",
+  "mysql",
+  "sqlserver",
+  "postgres",
+  "oracle",
+  "mongodb",
+  "dynamodb"
+];
+const catalog = {
+  json: { npm: "@deterministic-code/datasources-json", cargo: "datasources-json", nuget: "Datasources.Json" },
+  memory: { npm: "@deterministic-code/datasources-memory", cargo: "datasources-memory", nuget: "Datasources.Memory" },
+  sqlite: { npm: "@deterministic-code/datasources-sqlite", cargo: "datasources-sqlite", nuget: "Datasources.Sqlite" },
+  xml: { npm: "@deterministic-code/datasources-xml", cargo: "datasources-xml", nuget: "Datasources.Xml" },
+  yaml: { npm: "@deterministic-code/datasources-yaml", cargo: "datasources-yaml", nuget: "Datasources.Yaml" },
+  mysql: {
+    npm: "@deterministic-code/datasources-mysql",
+    cargo: "datasources-mysql",
+    nuget: "Datasources.Mysql"
+  },
+  sqlserver: {
+    npm: "@deterministic-code/datasources-sqlserver",
+    cargo: "datasources-sqlserver",
+    nuget: "Datasources.SqlServer"
+  },
+  postgres: {
+    npm: "@deterministic-code/datasources-postgres",
+    cargo: "datasources-postgres",
+    nuget: "Datasources.Postgres"
+  },
+  oracle: { npm: "@deterministic-code/datasources-oracle", cargo: "datasources-oracle", nuget: "Datasources.Oracle" },
+  mongodb: { npm: "@deterministic-code/datasources-mongodb", cargo: "datasources-mongodb", nuget: "Datasources.MongoDb" },
+  dynamodb: {
+    npm: "@deterministic-code/datasources-dynamodb",
+    cargo: "datasources-dynamodb",
+    nuget: "Datasources.DynamoDb"
+  }
+};
+const host = {
+  ts: { core: "@deterministic-code/datasources" },
+  rust: { core: "datasources" },
+  csharp: { core: "Datasources" }
+};
+const isProvider = (name) => providers.includes(name);
+const requireProviders = (names) => names.map(
+  (name) => isProvider(name) ? name : (() => {
+    throw new Error(`Unknown provider: ${name}. Choose from: ${providers.join(", ")}`);
+  })()
+);
+export {
+  catalog,
+  host,
+  isProvider,
+  providers,
+  requireProviders
+};

package/dist/commands.js

@@ -0,0 +1,51 @@
+import { catalog, host } from "./catalog.js";
+import { csharpTarget } from "./detect.js";
+const addCommands = (ecosystem, names, entries) => ({
+  ts: () => npmInstall(names),
+  rust: () => cargoAdd(names),
+  csharp: () => dotnetAdd(names, csharpTarget(entries))
+})[ecosystem]();
+const removeCommands = (ecosystem, names, _remaining, entries) => ({
+  ts: () => npmUninstall(names),
+  rust: () => cargoRemove(names),
+  csharp: () => dotnetRemove(names, csharpTarget(entries))
+})[ecosystem]();
+const npmInstall = (names) => [
+  {
+    command: "npm",
+    args: ["install", host.ts.core, ...names.map((name) => catalog[name].npm)]
+  }
+];
+const npmUninstall = (names) => {
+  const pkgs = names.map((name) => catalog[name].npm);
+  return pkgs.length ? [{ command: "npm", args: ["uninstall", ...pkgs] }] : [];
+};
+const cargoAdd = (names) => [
+  { command: "cargo", args: ["add", host.rust.core] },
+  ...names.map((name) => ({
+    command: "cargo",
+    args: ["add", catalog[name].cargo]
+  }))
+];
+const cargoRemove = (names) => names.map((name) => ({ command: "cargo", args: ["remove", catalog[name].cargo] }));
+const dotnetAdd = (names, project) => {
+  const prefix = project === "." ? [] : [project];
+  return [
+    { command: "dotnet", args: ["add", ...prefix, "package", host.csharp.core] },
+    ...names.map((name) => ({
+      command: "dotnet",
+      args: ["add", ...prefix, "package", catalog[name].nuget]
+    }))
+  ];
+};
+const dotnetRemove = (names, project) => {
+  const prefix = project === "." ? [] : [project];
+  return names.map((name) => ({
+    command: "dotnet",
+    args: ["remove", ...prefix, "package", catalog[name].nuget]
+  }));
+};
+export {
+  addCommands,
+  removeCommands
+};

package/dist/detect.js

@@ -0,0 +1,23 @@
+const detect = (entries) => [
+  ...entries.includes("package.json") ? ["ts"] : [],
+  ...entries.includes("Cargo.toml") ? ["rust"] : [],
+  ...entries.some((e) => e.endsWith(".csproj") || e.endsWith(".sln") || e.endsWith(".slnx")) ? ["csharp"] : []
+];
+const resolveEcosystem = (found, explicit) => {
+  if (explicit) return explicit;
+  if (found.length === 1) return found[0];
+  throw new Error(
+    found.length === 0 ? "No package.json, Cargo.toml, or .csproj/.sln in this directory" : "Multiple project types found. Pass --ecosystem ts|rust|csharp"
+  );
+};
+const csharpTarget = (entries) => {
+  const projects = entries.filter((e) => e.endsWith(".csproj")).sort();
+  return projects.find((p) => !/tests?\.csproj$/i.test(p)) ?? projects[0] ?? entries.find((e) => e.endsWith(".sln") || e.endsWith(".slnx")) ?? ".";
+};
+const isEcosystem = (value) => value === "ts" || value === "rust" || value === "csharp";
+export {
+  csharpTarget,
+  detect,
+  isEcosystem,
+  resolveEcosystem
+};

package/dist/env.js

@@ -0,0 +1,93 @@
+const scheme = (url) => url.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/)?.[1]?.toLowerCase();
+const knownEnvKeys = ["INSTALLED_PROVIDERS", "PROVIDER", "DATASOURCE_URL"];
+const droppedEnvKeys = [
+  "DATABASE_URL",
+  "DATABASE_SCHEMA",
+  "DEFAULT_PROVIDER",
+  "DEFAULT_DATASOURCE_URL",
+  "DATASOURCE_PROVIDER",
+  "DATASOURCE_PROVIDERS",
+  "SQLITE_FILENAME"
+];
+const schemaOf = (url) => {
+  const query = url.split("#")[0]?.split("?")[1] ?? "";
+  for (const part of query.split("&")) {
+    if (!part) continue;
+    const eq = part.indexOf("=");
+    const key = decodeURIComponent(eq < 0 ? part : part.slice(0, eq));
+    if (key !== "schema") continue;
+    return decodeURIComponent(eq < 0 ? "" : part.slice(eq + 1));
+  }
+  return "";
+};
+const withSchema = (url, schema) => {
+  if (!url || !schema || schemaOf(url)) return url;
+  const hash = url.indexOf("#");
+  const base = hash < 0 ? url : url.slice(0, hash);
+  const fragment = hash < 0 ? "" : url.slice(hash);
+  return `${base}${base.includes("?") ? "&" : "?"}schema=${encodeURIComponent(schema)}${fragment}`;
+};
+const urlOf = (env) => env.DATASOURCE_URL || "";
+const installedOf = (env) => env.INSTALLED_PROVIDERS || scheme(urlOf(env)) || "";
+const parseEnv = (text) => Object.fromEntries(
+  text.split(/\r?\n/).filter((line) => line.trim() && !line.trimStart().startsWith("#") && line.includes("=")).map((line) => {
+    const i = line.indexOf("=");
+    return [line.slice(0, i).trim(), line.slice(i + 1)];
+  })
+);
+const serializeEnv = (map) => {
+  const extra = Object.keys(map).filter(
+    (key) => !knownEnvKeys.includes(key) && !droppedEnvKeys.includes(key)
+  );
+  return [...knownEnvKeys.filter((key) => key in map), ...extra].map((key) => `${key}=${map[key]}`).join("\n").concat("\n");
+};
+const splitProviders = (value) => [
+  ...new Set(
+    value.split(",").map((name) => name.trim()).filter(Boolean)
+  )
+];
+const ensureProviders = (names, defaultProvider) => names.includes(defaultProvider) ? names : [...names, defaultProvider];
+const updateEnvProviders = (env, add, remove) => {
+  const current = splitProviders(installedOf(env));
+  const next = [
+    ...current.filter((name) => !remove.includes(name)),
+    ...add.filter((name) => !current.includes(name))
+  ];
+  const fallback = scheme(urlOf(env)) ?? next[0] ?? "sqlite";
+  const {
+    DATABASE_URL: _u,
+    DATABASE_SCHEMA: _s,
+    DEFAULT_PROVIDER: _d,
+    DEFAULT_DATASOURCE_URL: _du,
+    DATASOURCE_PROVIDER: _p,
+    DATASOURCE_PROVIDERS: _ps,
+    SQLITE_FILENAME: _f,
+    ...rest
+  } = env;
+  const url = urlOf(env);
+  return {
+    ...rest,
+    ...url ? { DATASOURCE_URL: url } : {},
+    INSTALLED_PROVIDERS: (next.length ? next : [fallback]).join(",")
+  };
+};
+const answersFromEnv = (env) => {
+  const url = urlOf(env) || (installedOf(env).includes("sqlite") || !installedOf(env) ? "sqlite:///:memory:" : "");
+  return {
+    providers: splitProviders(installedOf(env) || scheme(url) || "sqlite"),
+    url,
+    schema: schemaOf(url)
+  };
+};
+export {
+  answersFromEnv,
+  ensureProviders,
+  knownEnvKeys,
+  parseEnv,
+  schemaOf,
+  scheme,
+  serializeEnv,
+  splitProviders,
+  updateEnvProviders,
+  withSchema
+};

package/dist/generate/CSharpRepositories.js

@@ -0,0 +1,134 @@
+import { content } from "@deterministic-code/generators-common/generate-entry";
+import {
+  childClass,
+  childField,
+  isLinked,
+  children as childModels,
+  pluralPascal,
+  repositoryFile
+} from "./RepositoryModel.js";
+const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+const enrichment = (item, host = "ctor") => {
+  const via = childField("csharp", item.via, item.viaType);
+  const head = `"${quote(item.destination)}", "${quote(item.source)}", "${quote(item.relatedKey)}"`;
+  if (host === "ctor" && isLinked(item)) {
+    const link = childField("csharp", item.link, item.linkType);
+    return `AddLinked(new(${head}, Association: new("${quote(item.parentFk)}", "${quote(item.relatedFk)}")), ${via}, ${link});`;
+  }
+  const related = item.relatedProperty === void 0 ? "" : `, "${quote(item.relatedProperty)}"`;
+  const type = item.kind === "object" ? "" : item.kind === "dictionary" ? ", Type: EnrichmentPropertyType.Dictionary" : ", Type: EnrichmentPropertyType.List";
+  const call = host === "readonly" ? "repo.AddEnriched" : "AddEnriched";
+  return `${call}(new(${head}${related}${type}), ${via});`;
+};
+const tokenWhere = (model, token, expected) => {
+  const [first, ...rest] = [...model.ids, token.property];
+  const value = (name) => name === token.property ? expected : `item.${name}`;
+  return `new("${quote(first)}", eq, Value.From(${value(first)}))${rest.map((name) => `.And("${quote(name)}", eq, Value.From(${value(name)}))`).join("")}`;
+};
+const occMethods = (model, type) => {
+  const token = model.optimisticConcurrency;
+  if (token === void 0) return "";
+  const bump = token.increment ? `
+        item.${token.property} += 1;` : "";
+  return `
+    public new async Task<Response> Update(${type} item, IWhere? byWhere = null)
+    {
+        var expected = item.${token.property};${bump}
+        var response = await base.Update(item, byWhere ?? ${tokenWhere(model, token, "expected")});
+        return response.RowsAffected == 1 ? response : throw new DatasourceException($"Update affected {response.RowsAffected} rows");
+    }
+
+    public new async Task<Response> Delete(${type} item, IWhere? byWhere = null)
+    {
+        var response = await base.Delete(item, byWhere ?? ${tokenWhere(model, token, `item.${token.property}`)});
+        return response.RowsAffected == 1 ? response : throw new DatasourceException($"Delete affected {response.RowsAffected} rows");
+    }
+`;
+};
+const createReadonly = (model, type) => {
+  const children = childModels(model);
+  if (children.length === 0 && model.enrichments.length === 0)
+    return `    public static IReadonlyRepository<${type}> CreateReadonly(IConnection connection) =>
+        new ReadonlyRepository<${type}>(connection, Options());`;
+  const locals = children.map((child) => `        var ${childField("csharp", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`);
+  const enrich = model.enrichments.map((item) => `        ${enrichment(item, "readonly")}`);
+  return `    public static IReadonlyRepository<${type}> CreateReadonly(IConnection connection)
+    {
+        var repo = new ReadonlyRepository<${type}>(connection, Options());
+${locals.join("\n")}
+${enrich.join("\n")}
+        return repo;
+    }`;
+};
+const csharpRepositories = (models) => {
+  const files = models.map((model) => {
+    const type = `${model.typeHome === "view" ? "Backend.Types.View" : "Backend.Types.Datasource"}.${model.typeName}`;
+    const children = childModels(model);
+    const fields = children.map((child) => `    public ${childClass(child.typeName)} ${childField("csharp", child.specName, child.typeName)} { get; }`);
+    const lines = [
+      ...children.map((child) => `        ${childField("csharp", child.specName, child.typeName)} = new ${childClass(child.typeName)}(connection);`),
+      ...model.enrichments.map((item) => `        ${enrichment(item)}`)
+    ];
+    const mapping = `        PropertyMappings = new DictionaryMapper<string>(new Dictionary<string, string>
+        {
+${model.propertyMappings.map((pair) => `            ["${quote(pair.from)}"] = "${quote(pair.to)}",`).join("\n")}
+        }),
+`;
+    const constructor = lines.length === 0 ? `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options()) { }` : `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options())
+    {
+${lines.join("\n")}
+    }`;
+    const ids = model.ids.map((name) => `"${quote(name)}"`).join(", ");
+    const read = model.readProperties.map((name) => `"${quote(name)}"`).join(", ");
+    const implementsOcc = model.optimisticConcurrency === void 0 ? "" : `, ICRUDRepository<${type}>`;
+    const usings = model.optimisticConcurrency === void 0 ? "using Datasources;\n" : "using Datasources;\nusing static Datasources.Cmp;\n";
+    return content(
+      repositoryFile("csharp", model),
+      `${usings}
+public sealed class ${model.typeName}Repository : CRUDRepository<${type}>${implementsOcc}
+{
+${fields.length === 0 ? "" : `${fields.join("\n")}
+
+`}${constructor}
+
+${createReadonly(model, type)}
+${occMethods(model, type)}
+    static CRUDRepositoryOptions<${type}> Options() => new()
+    {
+        Entity = "${quote(model.entity)}",
+        EntityMapper = new DictionaryMapper<string>(new Dictionary<string, string> { ["${quote(model.entity)}"] = "${quote(model.table)}" }),
+${mapping}        Ids = [${ids}],
+        ReadProperties = [${read}],
+    };
+}
+`
+    );
+  });
+  const register = models.map((model) => {
+    const type = `${model.typeName}Repository`;
+    return `        factory.Register("${quote(model.entity)}", "${quote(pluralPascal(model.typeName))}", connection => new ${type}(connection), connection => ${type}.CreateReadonly(connection));`;
+  });
+  return [
+    ...files,
+    content(
+      "RepositoryRegistry.cs",
+      `using System.Runtime.CompilerServices;
+using Datasources;
+
+public static class RepositoryRegistry
+{
+    [ModuleInitializer]
+    internal static void Bind() => RepositoryFactory.Bind(Register);
+
+    public static void Register(RepositoryFactory factory)
+    {
+${register.join("\n")}
+    }
+}
+`
+    )
+  ];
+};
+export {
+  csharpRepositories
+};

package/dist/generate/DeterministicProvider.js

@@ -0,0 +1,53 @@
+import { generate as csharpDatasourceTypes } from "@deterministic-code/csharp-generators/generate-datasource-types";
+import { generate as csharpViewTypes } from "@deterministic-code/csharp-generators/generate-view-types";
+import { generateSql } from "@deterministic-code/datasources-code-generators";
+import { generate as rustDatasourceTypes } from "@deterministic-code/rust-generators/generate-datasource-types";
+import { generate as rustViewTypes } from "@deterministic-code/rust-generators/generate-view-types";
+import { generate as typescriptDatasourceTypes } from "@deterministic-code/typescript-generators/generate-datasource-types";
+import { generate as typescriptViewTypes } from "@deterministic-code/typescript-generators/generate-view-types";
+import { DeterministicParser } from "@deterministic-code/deterministic-generators-common/parser";
+import { csharpRepositories } from "./CSharpRepositories.js";
+import { rustRepositories } from "./RustRepositories.js";
+import { typescriptRepositories } from "./TypeScriptRepositories.js";
+import { planRepositories } from "./RepositoryPlan.js";
+const place = (dir, entries) => entries.map((entry) => ({ ...entry, filename: `${dir}/${entry.filename}` }));
+const typePacks = {
+  csharp: { datasource: csharpDatasourceTypes, views: csharpViewTypes },
+  typescript: { datasource: typescriptDatasourceTypes, views: typescriptViewTypes },
+  rust: { datasource: rustDatasourceTypes, views: rustViewTypes }
+};
+const repositoryPacks = {
+  csharp: csharpRepositories,
+  typescript: typescriptRepositories,
+  rust: rustRepositories
+};
+const context = (request) => ({ reader: request.reader, settings: request.settings });
+const dialectsOf = (settings) => {
+  const out = [];
+  for (const name of (settings["backend.datasources"] ?? "").split(",")) {
+    const key = name.trim();
+    if (key !== "" && !out.includes(key)) out.push(key);
+  }
+  return out;
+};
+const deterministic = {
+  name: "deterministic",
+  generateTypes: async (request) => {
+    const pack = typePacks[request.dialect];
+    const ctx = context(request);
+    const datasource = await pack.datasource(ctx);
+    const views = await pack.views(ctx);
+    return request.dialect === "typescript" ? [
+      ...place("typescript/types/generated/datasource", datasource),
+      ...place("typescript/types/generated/views", views)
+    ] : place(request.dialect, [...datasource, ...views]);
+  },
+  generateRepositories: async (request) => {
+    const spec = await DeterministicParser(request.reader).parse(request.settings);
+    return place(`${request.dialect}/repositories`, repositoryPacks[request.dialect](planRepositories(spec, request.dialect, request.settings), request.settings));
+  },
+  generateDatasource: async (request) => place("sql", await generateSql(context(request), dialectsOf(request.settings)))
+};
+export {
+  deterministic
+};

package/dist/generate/GenerateRequest.js

@@ -0,0 +1,6 @@
+const dialects = ["csharp", "typescript", "rust"];
+const isDialect = (value) => dialects.includes(value);
+export {
+  dialects,
+  isDialect
+};

package/dist/generate/RepositoryModel.js

@@ -0,0 +1,64 @@
+const repositoryFile = (dialect, model) => dialect === "csharp" ? `${model.typeName}Repository.cs` : dialect === "typescript" ? `${model.specName.replaceAll("_", "-")}-repository.ts` : `${model.specName}_repository.rs`;
+const childField = (dialect, specName, typeName) => dialect === "csharp" ? typeName : dialect === "typescript" ? camel(specName) : specName;
+const childClass = (typeName) => `${typeName}Repository`;
+const isLinked = (item) => item.kind === "linked";
+const children = (model) => {
+  const rows = /* @__PURE__ */ new Map();
+  for (const item of model.enrichments) {
+    rows.set(item.via, item.viaType);
+    if (isLinked(item)) rows.set(item.link, item.linkType);
+  }
+  return [...rows].map(([specName, typeName]) => ({ specName, typeName }));
+};
+const camel = (name) => name.split("_").map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+const uncountable = /* @__PURE__ */ new Set(["sheep", "fish", "series", "species", "deer", "news"]);
+const irregular = {
+  person: "people",
+  child: "children",
+  man: "men",
+  woman: "women",
+  mouse: "mice",
+  goose: "geese",
+  tooth: "teeth",
+  foot: "feet",
+  ox: "oxen"
+};
+const irregularSingular = Object.fromEntries(Object.entries(irregular).map(([singular, plural]) => [plural, singular]));
+const vowel = (c) => "aeiou".includes(c);
+const consonant = (c) => /[a-z]/.test(c) && !vowel(c);
+const yies = (word) => word.length >= 4 && word.endsWith("ies") && consonant(word[word.length - 4]);
+const consonantY = (word) => word.length >= 2 && word.endsWith("y") && consonant(word[word.length - 2]);
+const sibilant = (word) => word.endsWith("ch") || word.endsWith("sh") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ss") || word.length >= 2 && word.endsWith("s") && !word.endsWith("es") && vowel(word[word.length - 2]);
+const sibilantEs = (word) => word.length > 2 && word.endsWith("es") && sibilant(word.slice(0, -2));
+const restore = (original, result) => original[0] === original[0]?.toUpperCase() ? result[0]?.toUpperCase() + result.slice(1) : result;
+const pluralWord = (word) => {
+  const lower = word.toLowerCase();
+  const plural = uncountable.has(lower) || lower in irregularSingular ? lower : irregular[lower] ?? (yies(lower) || sibilantEs(lower) ? lower : sibilant(lower) ? `${lower}es` : consonantY(lower) ? `${lower.slice(0, -1)}ies` : lower.endsWith("s") ? lower : `${lower}s`);
+  return restore(word, plural);
+};
+const pluralPascal = (typeName) => {
+  const words = typeName.match(/[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|[0-9]+/g) ?? [typeName];
+  const last = words[words.length - 1];
+  words[words.length - 1] = pluralWord(last);
+  return words.join("");
+};
+const pluralSnake = (specName) => {
+  const parts = specName.split("_");
+  const last = parts[parts.length - 1];
+  parts[parts.length - 1] = pluralWord(last);
+  return parts.join("_");
+};
+const pluralCamel = (typeName) => {
+  const pascal = pluralPascal(typeName);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+};
+export {
+  childClass,
+  childField,
+  children,
+  isLinked,
+  pluralCamel,
+  pluralPascal,
+  pluralSnake,
+  repositoryFile
+};

package/dist/generate/RepositoryPlan.js

@@ -0,0 +1,171 @@
+import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
+import { createDatasourceNaming } from "@deterministic-code/generators-common/datasource-naming";
+import { identityColumns, isCollectionField, isDictionaryType, isOwnerIdentityRef, persistedColumnFields } from "@deterministic-code/generators-common/spec-types";
+const referenceOf = (references) => {
+  if (references === void 0) return void 0;
+  const [type, field] = [references].flat().join(".").split(".");
+  return type !== void 0 && field !== void 0 && type.length > 0 && field.length > 0 ? { type, field } : void 0;
+};
+const childNames = (model) => [
+  ...new Set(model.enrichments.flatMap((item) => item.link === void 0 ? [item.via] : [item.via, item.link]))
+];
+const guardCycles = (models) => {
+  const byName = new Map(models.map((model) => [model.specName, model]));
+  const walk = (model, stack) => {
+    if (stack.includes(model.specName)) throw new Error(`repository cycle: ${[...stack, model.specName].join(" -> ")}`);
+    for (const child of childNames(model)) {
+      const next = byName.get(child);
+      if (next) walk(next, [...stack, model.specName]);
+    }
+  };
+  for (const model of models) walk(model, []);
+};
+const planRepositories = (spec, dialect, settings) => {
+  const casing = createCasingStrategy(dialect, settings);
+  const naming = createDatasourceNaming(settings);
+  const types = new Map(spec.types.map((type) => [type.name, type]));
+  const expanded = new Map(spec.expandedTypes.map((type) => [type.name, type]));
+  const referenced = /* @__PURE__ */ new Set();
+  for (const type of spec.types) {
+    for (const field of type.fields) {
+      const ref = referenceOf(field.references);
+      if (ref) referenced.add(ref.type);
+    }
+  }
+  const viewByTable = /* @__PURE__ */ new Map();
+  for (const type of spec.types) {
+    if (type.tags.includes("view_type") && type.inherits !== void 0) viewByTable.set(type.inherits, type);
+  }
+  const abstractParent = (table) => {
+    const inherited = spec.types.some((type) => type.inherits === table.name && type.tags.includes("datasource_type"));
+    return inherited && table.mapping === void 0 && !referenced.has(table.name);
+  };
+  const repoName = (tableName) => viewByTable.get(tableName)?.name ?? tableName;
+  const property = (name) => casing.convertFields(name);
+  const identity = (name) => property(identityColumns(expanded.get(name), spec.datasource.find((table) => table.name === name))[0] ?? "id");
+  const included = new Set(spec.datasource.map((table) => table.name));
+  const models = spec.datasource.flatMap((table) => {
+    if (abstractParent(table)) return [];
+    const view = types.get(table.name);
+    if (view?.tags.includes("view_type") === true && view.inherits !== void 0 && included.has(view.inherits))
+      return [];
+    const authored = viewByTable.get(table.name) ?? types.get(table.name);
+    const full = expanded.get(authored.name);
+    const tableType = expanded.get(table.name) ?? types.get(table.name) ?? full;
+    const overlays = new Map(table.fields.map((field) => [field.name, field]));
+    const projected = new Set(Object.values(authored.mapping ?? {}));
+    const columns = (isDictionaryType(tableType) ? persistedColumnFields(tableType, expanded) : tableType.fields).filter((field) => !isCollectionField(field) && !projected.has(field.name));
+    return [
+      {
+        specName: authored.name,
+        typeName: casing.convertTypes(authored.name),
+        typeHome: authored.tags.includes("view_type") ? "view" : "datasource",
+        entity: casing.convertTypes(authored.name),
+        table: naming.resolveTable(table.name, table.mapping),
+        propertyMappings: columns.flatMap((field) => {
+          const from = property(field.name);
+          const to = naming.resolveColumn(field.name, overlays.get(field.name)?.mapping);
+          return from === to ? [] : [{ from, to }];
+        }),
+        ids: identityColumns(tableType, table).map(property),
+        readProperties: columns.map((field) => property(field.name)),
+        optimisticConcurrency: concurrencyToken(table, tableType, property),
+        enrichments: relations(authored, full, casing, types, expanded, repoName, identity)
+      }
+    ];
+  });
+  guardCycles(models);
+  return models.sort((left, right) => left.specName.localeCompare(right.specName));
+};
+const concurrencyToken = (table, tableType, property) => {
+  if (table.useOptimisticConcurrency === false) return void 0;
+  const token = table.fields.find((field) => field.isOptimisticConcurrency === true);
+  if (token === void 0) return void 0;
+  return {
+    property: property(token.name),
+    increment: tableType.fields.some(
+      (field) => field.name === token.name && ["integer", "number"].includes(field.type)
+    )
+  };
+};
+const relations = (authored, full, casing, types, expanded, repoName, identity) => {
+  const property = (name) => casing.convertFields(name);
+  const named = (tableName) => {
+    const via = repoName(tableName);
+    return { via, viaType: casing.convertTypes(via) };
+  };
+  const planned = [];
+  const source = identity(authored.inherits ?? authored.name);
+  for (const field of authored.fields) {
+    if (!isCollectionField(field)) continue;
+    if (field.isMap === true) {
+      const dict = expanded.get(field.base) ?? types.get(field.base);
+      const owner = dict?.fields.find((item) => isOwnerIdentityRef(item.references, dict.name, expanded));
+      if (dict === void 0 || owner === void 0) continue;
+      const via = named(dict.name);
+      const value = dict.fields.find((item) => item.name === "value");
+      const nested = value === void 0 ? void 0 : expanded.get(value.base) ?? types.get(value.base);
+      planned.push({
+        destination: property(field.name),
+        source,
+        relatedKey: property(owner.name),
+        relatedProperty: nested === void 0 ? property("value") : void 0,
+        kind: "dictionary",
+        via: via.via,
+        viaType: via.viaType
+      });
+      continue;
+    }
+    const ref = referenceOf(field.references);
+    if (!ref) continue;
+    const target = types.get(ref.type);
+    const other = target?.fields.find((item) => item.name !== ref.field);
+    const otherRef = other === void 0 ? void 0 : referenceOf(other.references);
+    if (target?.tags.includes("many_to_many") === true && other !== void 0 && otherRef !== void 0) {
+      const via = named(otherRef.type);
+      const link = named(ref.type);
+      planned.push({
+        destination: property(field.name),
+        source,
+        relatedKey: identity(otherRef.type),
+        kind: "linked",
+        via: via.via,
+        viaType: via.viaType,
+        link: link.via,
+        linkType: link.viaType,
+        parentFk: property(ref.field),
+        relatedFk: property(other.name)
+      });
+    } else {
+      const via = named(ref.type);
+      planned.push({
+        destination: property(field.name),
+        source,
+        relatedKey: property(ref.field),
+        kind: "list",
+        via: via.via,
+        viaType: via.viaType
+      });
+    }
+  }
+  for (const [key, dest] of Object.entries(authored.mapping ?? {})) {
+    const dotted = key.includes(".") ? key.split(".") : void 0;
+    const memberName = dotted?.[0] ?? (authored.union ?? []).find((name) => expanded.get(name).fields.some((field) => field.name === key));
+    const fk = memberName === void 0 ? void 0 : full.fields.find((field) => referenceOf(field.references)?.type === memberName);
+    if (memberName === void 0 || fk === void 0) continue;
+    const via = named(memberName);
+    planned.push({
+      destination: property(dest),
+      source: property(fk.name),
+      relatedKey: identity(memberName),
+      relatedProperty: property(dotted?.[1] ?? key),
+      kind: "object",
+      via: via.via,
+      viaType: via.viaType
+    });
+  }
+  return planned;
+};
+export {
+  planRepositories
+};