@deterministic-code/datasources-cli 0.1.9 → 0.1.11

package/dist/generate/CSharpRepositories.js

@@ -7,6 +7,7 @@ import {
   pluralPascal,
   repositoryFile
 } from "./RepositoryModel.js";
+import { writeList } from "./writeLists.js";
 const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
 const enrichment = (item, host = "ctor") => {
   const via = childField("csharp", item.via, item.viaType);
@@ -49,12 +50,12 @@ 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());`;
+        new ReadonlyRepository<${type}>(connection, Options(connection));`;
   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());
+        var repo = new ReadonlyRepository<${type}>(connection, Options(connection));
 ${locals.join("\n")}
 ${enrich.join("\n")}
         return repo;
@@ -74,12 +75,14 @@ const csharpRepositories = (models) => {
 ${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())
+    const constructor = lines.length === 0 ? `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options(connection)) { }` : `    public ${model.typeName}Repository(IConnection connection) : base(connection, Options(connection))
     {
 ${lines.join("\n")}
     }`;
     const ids = model.ids.map((name) => `"${quote(name)}"`).join(", ");
     const read = model.readProperties.map((name) => `"${quote(name)}"`).join(", ");
+    const create = writeList("csharp", model, "create");
+    const update = writeList("csharp", model, "update");
     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(
@@ -93,12 +96,14 @@ ${fields.length === 0 ? "" : `${fields.join("\n")}
 
 ${createReadonly(model, type)}
 ${occMethods(model, type)}
-    static CRUDRepositoryOptions<${type}> Options() => new()
+    static CRUDRepositoryOptions<${type}> Options(IConnection connection) => new()
     {
         Entity = "${quote(model.entity)}",
         EntityMapper = new DictionaryMapper<string>(new Dictionary<string, string> { ["${quote(model.entity)}"] = "${quote(model.table)}" }),
 ${mapping}        Ids = [${ids}],
         ReadProperties = [${read}],
+        CreateProperties = ${create},
+        UpdateProperties = ${update},
     };
 }
 `

package/dist/generate/DeterministicProvider.js

@@ -10,6 +10,7 @@ import { csharpRepositories } from "./CSharpRepositories.js";
 import { rustRepositories } from "./RustRepositories.js";
 import { typescriptRepositories } from "./TypeScriptRepositories.js";
 import { planRepositories } from "./RepositoryPlan.js";
+import { datasourceEnginesOf, engineDatasourceOf, overlayDatasource } from "./datasourceYaml.js";
 const place = (dir, entries) => entries.map((entry) => ({ ...entry, filename: `${dir}/${entry.filename}` }));
 const typePacks = {
   csharp: { datasource: csharpDatasourceTypes, views: csharpViewTypes },
@@ -22,6 +23,33 @@ const repositoryPacks = {
   rust: rustRepositories
 };
 const context = (request) => ({ reader: request.reader, settings: request.settings });
+const withProviderWrites = async (request, models) => {
+  const byProvider = {};
+  for (const engine of await datasourceEnginesOf(request.reader, request.settings)) {
+    const yaml = await engineDatasourceOf(request.reader, engine);
+    if (yaml === void 0) continue;
+    byProvider[engine] = planRepositories(
+      await DeterministicParser(overlayDatasource(request.reader, yaml)).parse(request.settings),
+      request.dialect,
+      request.settings
+    );
+  }
+  return Object.keys(byProvider).length === 0 ? models : models.map((model) => ({
+    ...model,
+    writesByProvider: Object.fromEntries(
+      Object.entries(byProvider).map(([engine, planned]) => {
+        const found = planned.find((item) => item.specName === model.specName);
+        return [
+          engine,
+          {
+            create: found?.createProperties ?? model.createProperties,
+            update: found?.updateProperties ?? model.updateProperties
+          }
+        ];
+      })
+    )
+  }));
+};
 const dialectsOf = (settings) => {
   const out = [];
   for (const name of (settings["backend.datasources"] ?? "").split(",")) {
@@ -44,7 +72,11 @@ const deterministic = {
   },
   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));
+    const models = planRepositories(spec, request.dialect, request.settings);
+    return place(
+      `${request.dialect}/repositories`,
+      repositoryPacks[request.dialect](await withProviderWrites(request, models), request.settings)
+    );
   },
   generateDatasource: async (request) => place("sql", await generateSql(context(request), dialectsOf(request.settings)))
 };

package/dist/generate/RepositoryPlan.js

@@ -1,6 +1,7 @@
 import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { createDatasourceNaming } from "@deterministic-code/generators-common/datasource-naming";
 import { identityColumns, isCollectionField, persistedColumnFields } from "@deterministic-code/generators-common/spec-types";
+import { writeInclusionOf } from "@deterministic-code/datasources-code-generators/sql/common/write-inclusion";
 const referenceOf = (references) => {
   if (references === void 0) return void 0;
   const [type, field] = [references].flat().join(".").split(".");
@@ -70,6 +71,12 @@ const planRepositories = (spec, dialect, settings) => {
         }),
         ids: identityColumns(tableType, table).map(property),
         readProperties: columns.map((field) => property(field.name)),
+        createProperties: columns.filter(
+          (field) => writeInclusionOf(field, identityColumns(tableType, table), overlays.get(field.name)).includeInCreate
+        ).map((field) => property(field.name)),
+        updateProperties: columns.filter(
+          (field) => writeInclusionOf(field, identityColumns(tableType, table), overlays.get(field.name)).includeInUpdate
+        ).map((field) => property(field.name)),
         optimisticConcurrency: concurrencyToken(table, tableType, property),
         enrichments: relations(authored, full, casing, types, expanded, repoName, identity)
       }

package/dist/generate/RustRepositories.js

@@ -1,5 +1,6 @@
 import { content } from "@deterministic-code/generators-common/generate-entry";
 import { childField, children as childModels, isLinked, pluralSnake, repositoryFile } from "./RepositoryModel.js";
+import { writeList } from "./writeLists.js";
 const rustString = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 const uses = `use datasources::{Association, Connection, CRUDRepository, CRUDRepositoryOptions, DictionaryMapper, Enrichment, EnrichmentPropertyType, ICRUDRepository, ReadonlyRepository, ReadonlyRepositoryMappingOptions, Result};
 use std::sync::Arc;`;
@@ -14,7 +15,9 @@ ${model.propertyMappings.map((pair) => `        (${rustString(pair.from)}.into()
         (${rustString(model.entity)}.into(), ${rustString(model.table)}.into()),
     ])));
 ${mapping}    options.ids = vec![${model.ids.map((id) => `${rustString(id)}.into()`).join(", ")}];
-    options.read_properties = vec![${model.readProperties.map((name) => `${rustString(name)}.into()`).join(", ")}];`;
+    options.read_properties = vec![${model.readProperties.map((name) => `${rustString(name)}.into()`).join(", ")}];
+    options.create_properties = Some(${writeList("rust", model, "create")});
+    options.update_properties = Some(${writeList("rust", model, "update")});`;
 };
 const readonlyOptions = (model) => {
   const mapping = model.propertyMappings.length === 0 ? "" : `    options.property_mappings = Some(Arc::new(DictionaryMapper::new([

package/dist/generate/TypeScriptRepositories.js

@@ -1,6 +1,7 @@
 import { createCasingStrategy } from "@deterministic-code/generators-common/casing-strategy";
 import { content } from "@deterministic-code/generators-common/generate-entry";
 import { childClass, childField, children as childModels, isLinked, pluralCamel, repositoryFile } from "./RepositoryModel.js";
+import { writeList } from "./writeLists.js";
 const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
 const enrichment = (item, host) => {
   const via = host === "this" ? `this.${childField("typescript", item.via, item.viaType)}` : childField("typescript", item.via, item.viaType);
@@ -58,8 +59,9 @@ const typescriptRepositories = (models, settings) => {
     const children = childModels(model);
     const mapping = model.propertyMappings.length === 0 ? "" : `propertyMappings: new DictionaryMapper([${model.propertyMappings.map((pair) => `["${quote(pair.from)}", "${quote(pair.to)}"]`).join(", ")}]), `;
     const head = `{ entity: "${quote(model.entity)}", entityMapper: new DictionaryMapper([["${quote(model.entity)}", "${quote(model.table)}"]]), ${mapping}`;
+    const writes = `createProperties: ${writeList("typescript", model, "create")}, updateProperties: ${writeList("typescript", model, "update")}`;
     const read = `readProperties: [${model.readProperties.map((name) => `"${quote(name)}"`).join(", ")}] }`;
-    const crudOptions = `${head}ids: [${model.ids.map((id) => `"${quote(id)}"`).join(", ")}], ${read}`;
+    const crudOptions = `${head}ids: [${model.ids.map((id) => `"${quote(id)}"`).join(", ")}], ${writes}, ${read}`;
     const readonlyOptions = `${head}${read}`;
     const fields = children.map((child) => `  readonly ${childField("typescript", child.specName, child.typeName)}: ${childClass(child.typeName)};`);
     const wrap = occWrap(model);

package/dist/generate/applyMigrations.js

@@ -6,15 +6,17 @@ import { providerByName } from "./providers.js";
 import { writeEntries } from "./writeEntries.js";
 const at = (root, path) => isAbsolute(path) ? path : join(root, path);
 const afterMigrations = (filename) => filename.replace(/^[^/]+\/migrations\//, "");
-const dialectsOf = (entries) => [
-  ...new Set(entries.map((entry) => entry.filename.split("/")[0]))
-];
 const applyMigrations = async (command, flags, deps) => {
   providerByName(command.provider);
   const loaded = await loadSpec(deps.fs, at(flags.cwd, command.input));
-  const entries = await generateSql({ reader: memoryReader(loaded.files), settings: loaded.settings });
-  if (command.migrationsPath !== void 0 && dialectsOf(entries).length > 1)
+  const listed = [
+    ...new Set(
+      loaded.settings["backend.datasources"].split(",").map((name) => name.trim()).filter((name) => name !== "")
+    )
+  ];
+  if (command.migrationsPath !== void 0 && listed.length > 1)
     throw new Error("--migrations-path requires a single SQL dialect in backend.datasources");
+  const entries = await generateSql({ reader: memoryReader(loaded.files), settings: loaded.settings });
   const remapped = command.migrationsPath === void 0 ? entries : entries.map((entry) => ({ ...entry, filename: afterMigrations(entry.filename) }));
   const root = at(flags.cwd, command.migrationsPath ?? command.migrationsRoot);
   if (flags.dryRun) {

package/dist/generate/datasourceYaml.js

@@ -0,0 +1,22 @@
+const known = ["sqlite", "mysql", "postgres", "sqlserver", "oracle"];
+const overlayDatasource = (reader, yaml) => ({
+  read: (name) => name === "datasource.yaml" ? Promise.resolve(yaml) : reader.read(name),
+  exists: (name) => name === "datasource.yaml" ? Promise.resolve(true) : reader.exists(name)
+});
+const engineDatasourceOf = async (reader, engine) => await reader.exists(`datasource.${engine}.yaml`) ? reader.read(`datasource.${engine}.yaml`) : void 0;
+const datasourceEnginesOf = async (reader, settings) => {
+  const engines = /* @__PURE__ */ new Set();
+  for (const name of (settings["backend.datasources"] ?? "").split(",")) {
+    const key = name.trim();
+    if (key !== "") engines.add(key);
+  }
+  for (const name of known) {
+    if (await reader.exists(`datasource.${name}.yaml`)) engines.add(name);
+  }
+  return [...engines];
+};
+export {
+  datasourceEnginesOf,
+  engineDatasourceOf,
+  overlayDatasource
+};

package/dist/generate/loadSpec.js

@@ -22,8 +22,13 @@ const loadSpec = async (fs, dir) => {
     if (text !== void 0) files[name] = text;
   }
   if (files["types.yaml"] === void 0) throw new Error(`missing types.yaml in ${dir}`);
-  files["datasource.yaml"] ??= defaultDatasourceYaml;
   const names = await fs.readdir(dir).catch(() => []);
+  for (const name of names) {
+    if (!/^datasource\.[a-z0-9]+\.yaml$/.test(name)) continue;
+    const text = await readOptional(fs, join(dir, name));
+    if (text !== void 0) files[name] = text;
+  }
+  files["datasource.yaml"] ??= files["datasource.sqlite.yaml"] ?? defaultDatasourceYaml;
   const diffs = names.filter((name) => versionDir.test(name)).sort();
   const versionFiles = [];
   for (const name of diffs) {

package/dist/generate/migrateUp.js

@@ -60,19 +60,26 @@ const applyMigrateUp = async (command, flags, deps, env = process.env) => {
     throw new Error(
       `migrate-up: provider ${provider} is not in backend.datasources (${dialects.join(", ") || "none"})`
     );
-  const args = [
+  const npx = (verb, extra = []) => [
     "--yes",
     "--package",
-    "github:deterministic-code/migraters",
-    "migrate-up",
+    "@deterministic-code/migraters",
+    verb,
     "--provider",
     provider,
     "--connection",
     connection,
-    ...command.migrationsPath ? ["--migrations-path", command.migrationsPath] : ["--migrations-root", command.migrationsRoot]
+    ...extra
   ];
-  deps.log(`$ npx ${args.join(" ")}`);
-  if (!flags.dryRun) await deps.run("npx", args, flags.cwd);
+  const setup = npx("migrate-setup");
+  const up = npx(
+    "migrate-up",
+    command.migrationsPath ? ["--migrations-path", command.migrationsPath] : ["--migrations-root", command.migrationsRoot]
+  );
+  deps.log(`$ npx ${setup.join(" ")}`);
+  if (!flags.dryRun) await deps.run("npx", setup, flags.cwd);
+  deps.log(`$ npx ${up.join(" ")}`);
+  if (!flags.dryRun) await deps.run("npx", up, flags.cwd);
 };
 export {
   applyMigrateUp

package/dist/generate/writeLists.js

@@ -0,0 +1,25 @@
+const quote = (value) => value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+const namesOf = (model, kind) => kind === "create" ? model.createProperties : model.updateProperties;
+const same = (left, right) => left.length === right.length && left.every((name, index) => name === right[index]);
+const csharpList = (names) => `[${names.map((name) => `"${quote(name)}"`).join(", ")}]`;
+const tsList = (names) => `[${names.map((name) => `"${quote(name)}"`).join(", ")}]`;
+const rustList = (names) => `vec![${names.map((name) => `"${quote(name)}".into()`).join(", ")}]`;
+const fallback = (model, kind) => model.writesByProvider?.sqlite?.[kind] ?? namesOf(model, kind);
+const writeList = (dialect, model, kind) => {
+  const by = model.writesByProvider;
+  const listed = namesOf(model, kind);
+  if (by === void 0 || Object.values(by).every((item) => same(item[kind], listed)))
+    return dialect === "csharp" ? csharpList(listed) : dialect === "typescript" ? tsList(listed) : rustList(listed);
+  const fallbackList = fallback(model, kind);
+  return dialect === "csharp" ? `connection.Provider switch
+        {
+${Object.entries(by).filter(([engine]) => engine !== "sqlite").map(([engine, item]) => `            "${quote(engine)}" => ${csharpList(item[kind])},`).join("\n")}
+            _ => ${csharpList(fallbackList)},
+        }` : dialect === "typescript" ? `({ ${Object.entries(by).filter(([engine]) => engine !== "sqlite").map(([engine, item]) => `${engine}: ${tsList(item[kind])}`).join(", ")} }[connection.provider] ?? ${tsList(fallbackList)})` : `match connection.provider() {
+        ${Object.entries(by).filter(([engine]) => engine !== "sqlite").map(([engine, item]) => `${engine === "mysql" || engine === "postgres" ? `"${engine}"` : `"${quote(engine)}"`} => ${rustList(item[kind])},`).join("\n        ")}
+        _ => ${rustList(fallbackList)},
+    }`;
+};
+export {
+  writeList
+};

package/dist/migrateInit.js

@@ -1,20 +1,24 @@
 const migrateProviders = ["sqlite", "postgres", "mysql", "sqlserver", "oracle"];
+const migrateLanguage = (ecosystem) => ecosystem === "ts" ? "typescript" : ecosystem;
 const sqlMigrateProviders = (names) => migrateProviders.filter((name) => names.includes(name));
-const migrateInitCommands = (dialects) => dialects.length === 0 ? [] : [
-  { command: "npm", args: ["install", "github:deterministic-code/migraters"] },
+const migrateInitCommands = (dialects, language) => dialects.length === 0 ? [] : [
+  { command: "npm", args: ["install", "@deterministic-code/migraters"] },
   {
     command: "npx",
     args: [
       "--yes",
       "--package",
-      "github:deterministic-code/migraters",
+      "@deterministic-code/migraters",
       "migrate-init",
+      "--language",
+      language,
       ...dialects.flatMap((name) => ["--dialect", name])
     ]
   }
 ];
 export {
   migrateInitCommands,
+  migrateLanguage,
   migrateProviders,
   sqlMigrateProviders
 };

package/dist/parse.js

@@ -3,7 +3,7 @@ import { isDialect } from "./generate/GenerateRequest.js";
 const generateTargets = ["all", "types", "repositories", "datasource"];
 const help = `Usage: datasources <command> [options]
 
-setup                 Interactive .env, provider install, and optional deterministic/
+setup [provider...]   Interactive .env, provider install, and optional deterministic/
   --cwd <dir>                 Consumer project directory (default: .)
   --ecosystem ts|rust|csharp  Required when more than one project type exists
   --dry-run                   Print package-manager commands without running them
@@ -88,7 +88,7 @@ const parseArgs = (argv, cwd = ".") => {
 };
 const commandOf = (verb, names, generate) => {
   if (verb === void 0 || verb === "help") return { kind: "help" };
-  if (verb === "setup") return { kind: "setup" };
+  if (verb === "setup") return { kind: "setup", providers: names };
   if (verb === "add") return { kind: "add", providers: names };
   if (verb === "remove") return { kind: "remove", providers: names };
   if (verb === "generate") return generateCommand(names, generate);

package/dist/run.js

@@ -3,12 +3,7 @@ import { join } from "node:path";
 import { catalog, requireProviders } from "./catalog.js";
 import { addCommands, removeCommands } from "./commands.js";
 import { csharpTarget, detect, resolveEcosystem } from "./detect.js";
-import {
-  answersFromEnv,
-  parseEnv,
-  serializeEnv,
-  updateEnvProviders
-} from "./env.js";
+import { parseEnv, serializeEnv, updateEnvProviders } from "./env.js";
 import { defaultDatasourceYaml } from "./generate/loadSpec.js";
 import {
   cargoProviders,
@@ -18,10 +13,10 @@ import {
 import { applyGenerate } from "./generate/applyGenerate.js";
 import { applyMigrations } from "./generate/applyMigrations.js";
 import { applyMigrateUp } from "./generate/migrateUp.js";
-import { migrateInitCommands, sqlMigrateProviders } from "./migrateInit.js";
+import { migrateInitCommands, migrateLanguage, sqlMigrateProviders } from "./migrateInit.js";
 import { help, parseArgs } from "./parse.js";
 import { applyVersion } from "./version/applyVersion.js";
-import { envFromAnswers, promptSetup, starterTypesYaml } from "./setup.js";
+import { answersForSetup, envFromAnswers, promptSetup, starterTypesYaml } from "./setup.js";
 import { wireRegister } from "./wireRegister.js";
 const run = async (argv, deps, cwd = ".") => {
   try {
@@ -35,7 +30,7 @@ const run = async (argv, deps, cwd = ".") => {
 };
 const dispatch = async (command, flags, deps) => {
   if (command.kind === "help") return deps.log(help.trimEnd());
-  if (command.kind === "setup") return applySetup(flags, deps);
+  if (command.kind === "setup") return applySetup(flags, deps, command.providers);
   if (command.kind === "add") return applyAddRemove(flags, deps, requireProviders(needNames(command.providers, "add")), []);
   if (command.kind === "remove") return applyAddRemove(flags, deps, [], requireProviders(needNames(command.providers, "remove")));
   if (command.kind === "version") return applyVersion(command, flags, deps);
@@ -59,7 +54,7 @@ const dispatch = async (command, flags, deps) => {
 const needNames = (names, verb) => names.length ? names : (() => {
   throw new Error(`Usage: datasources ${verb} <provider...>`);
 })();
-const applySetup = async (flags, deps) => {
+const applySetup = async (flags, deps, requested) => {
   const entries = await deps.fs.readdir(flags.cwd);
   const found = detect(entries);
   const existing = await readEnv(deps.fs, flags.cwd);
@@ -67,7 +62,7 @@ const applySetup = async (flags, deps) => {
   const typesPath = join(specDir, "types.yaml");
   const datasourcePath = join(specDir, "datasource.yaml");
   const missingSpec = await optional(deps.fs, typesPath) === void 0;
-  const answers = flags.yes ? { ...answersFromEnv(existing), ecosystem: flags.ecosystem, scaffold: false } : await promptSetup(deps.prompt, existing, found, flags.ecosystem, missingSpec);
+  const answers = flags.yes ? { ...answersForSetup(existing, requested), ecosystem: flags.ecosystem, scaffold: false } : await promptSetup(deps.prompt, existing, found, flags.ecosystem, missingSpec, requested);
   const ecosystem = resolveEcosystem(found, answers.ecosystem ?? flags.ecosystem);
   const selected = requireProviders(answers.providers);
   const installed = await readInstalled(deps.fs, flags.cwd, ecosystem, entries);
@@ -82,7 +77,7 @@ const applySetup = async (flags, deps) => {
     selected
   );
   await applyMigrateInit(flags, deps, ecosystem, selected);
-  const dialect = ecosystem === "ts" ? "typescript" : ecosystem;
+  const dialect = migrateLanguage(ecosystem);
   await wireRegister(flags.cwd, "generated", dialect, flags.dryRun, deps);
   if (!answers.scaffold) return;
   if (flags.dryRun) {
@@ -130,8 +125,7 @@ const applyPackages = async (flags, deps, ecosystem, entries, add, remove, remai
   }
 };
 const applyMigrateInit = async (flags, deps, ecosystem, remaining) => {
-  if (ecosystem !== "ts") return;
-  for (const proc of migrateInitCommands(sqlMigrateProviders(remaining))) {
+  for (const proc of migrateInitCommands(sqlMigrateProviders(remaining), migrateLanguage(ecosystem))) {
     deps.log(`$ ${proc.command} ${proc.args.join(" ")}`);
     if (!flags.dryRun) await deps.run(proc.command, proc.args, flags.cwd);
   }
@@ -166,9 +160,9 @@ const optional = async (fs, path) => {
     return void 0;
   }
 };
-const pluginFileName = (cargoName) => {
+const pluginFileName = (cargoName, platform = process.platform) => {
   const stem = cargoName.replaceAll("-", "_");
-  return process.platform === "win32" ? `${stem}.dll` : process.platform === "darwin" ? `lib${stem}.dylib` : `lib${stem}.so`;
+  return platform === "win32" ? `${stem}.dll` : platform === "darwin" ? `lib${stem}.dylib` : `lib${stem}.so`;
 };
 const copyPlugin = async (cwd, cargoName) => {
   const file = pluginFileName(cargoName);
@@ -193,5 +187,6 @@ const firstFile = async (paths) => {
   return void 0;
 };
 export {
+  pluginFileName,
   run
 };

package/dist/setup.js

@@ -14,8 +14,9 @@ types:
             type: string
             size: 128
 `;
-const promptSetup = async (prompt, env, found, explicit, askScaffold = false) => {
-  const defaults = answersFromEnv(env);
+const answersForSetup = (env, requested = []) => requested.length ? answersFromEnv({ ...env, INSTALLED_PROVIDERS: requested.join(",") }) : answersFromEnv(env);
+const promptSetup = async (prompt, env, found, explicit, askScaffold = false, requested = []) => {
+  const defaults = answersForSetup(env, requested);
   const ecosystem = explicit ?? (found.length === 1 ? found[0] : found.length === 0 ? void 0 : ecosystemOr(await prompt.select({
     message: "Project type",
     choices: found.map((value) => ({ name: value, value })),
@@ -48,6 +49,7 @@ const envFromAnswers = (answers) => {
   };
 };
 export {
+  answersForSetup,
   envFromAnswers,
   promptSetup,
   starterTypesYaml

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/generate-procedures.js

@@ -5,9 +5,10 @@ import { createCasing } from "./default-casing.js";
 import { byGroupsFromDatasource } from "./datasource-by-fields.js";
 import { SqlMapping } from "./sql-mapping.js";
 import { mapColumnType, q, renderSql } from "./sql-dialect.js";
-import { buildLiveTables, datasourceSettings, hasAuditColumns, overlayOf, sqlTablesFrom, } from "./sql-schema.js";
+import { buildLiveTables, datasourceSettings, hasAuditColumns, overlayOf, sqlTablesFrom, tableIdentity, } from "./sql-schema.js";
 import { procedureSpecs } from "./procedures/driver.js";
-import { createParamFields, pkFieldOf, writableNonAuditFields, } from "./procedures/helpers.js";
+import { createParamFields, pkFieldOf, updateParamFields } from "./procedures/helpers.js";
+import { writeInclusionOf } from "./write-inclusion.js";
 import { createBulkCreateStoredProcedureOf, createBulkDeleteStoredProcedureOf, createBulkUpdateStoredProcedureOf, createCreateStoredProcedureOf, createDeleteStoredProcedureOf, createReadStoredProcedureOf, createUpdateStoredProcedureOf, dropRoutineStatementOf, } from "../statements.js";
 const withNl = (text, casing) => {
     const out = casing.applyKeywords(text);
@@ -22,26 +23,38 @@ const payloadType = (dialect) => ({
 }[dialect] ?? "JSON");
 /** Create / read / update / delete / bulk procedure statements for one live table. */
 export const procedureStatementsForTable = (dialect, t, mapping, casing, groups) => {
+    const overlay = overlayOf(t);
+    const ids = tableIdentity(t);
     const table = {
         name: t.tableName,
         entityName: t.name,
-        fields: t.fields.map((f) => ({ name: f.name, type: f.type })),
-        pkName: pkName(t, overlayOf(t)),
+        fields: t.fields.map((f) => {
+            const flags = writeInclusionOf(f, ids, overlay.fields.find((item) => item.name === f.name));
+            return { name: f.name, type: f.type, ...flags };
+        }),
+        pkName: pkName(t, overlay),
     };
     const pk = pkFieldOf(table);
     const columnName = (logical) => mapping.columnName(t, logical);
     const columns = table.fields.map((f) => columnName(f.name));
-    const writable = writableNonAuditFields(table).map((f) => columnName(f.name));
+    const writable = updateParamFields(table).map((f) => columnName(f.name));
     const paramType = (field) => mapColumnType(dialect, field);
     const createdParams = createParamFields(table).map((f) => ({
         name: columnName(f.name),
         type: paramType(f),
     }));
     const typedColumns = table.fields.map((f) => ({ name: columnName(f.name), type: paramType(f) }));
+    const createColumns = createParamFields(table).map((f) => ({ name: columnName(f.name), type: paramType(f) }));
+    const updateColumns = [
+        { name: columnName(pk.name), type: paramType(pk) },
+        ...updateParamFields(table)
+            .filter((f) => f.name !== pk.name)
+            .map((f) => ({ name: columnName(f.name), type: paramType(f) })),
+    ];
     const payload = { name: "payload", type: payloadType(dialect) };
     const key = columnName(pk.name);
     const keyType = paramType(pk);
-    const audit = table.fields.some((f) => f.name === "updated") ? columnName("updated") : undefined;
+    const audit = table.fields.some((f) => f.name === "updated" && f.includeInUpdate) ? columnName("updated") : undefined;
     const generatedKey = pk.type === "uuid";
     const quoted = q(dialect, t.tableName);
     const statements = [];
@@ -55,18 +68,17 @@ export const procedureStatementsForTable = (dialect, t, mapping, casing, groups)
         });
         const updateParams = [
             ...byParams,
-            ...writableNonAuditFields(table)
+            ...updateParamFields(table)
                 .filter((f) => !proc.byProperties.includes(f.name))
                 .map((f) => ({ name: columnName(f.name), type: paramType(f) })),
-            ...(audit === undefined ? [] : [{ name: columnName("new_updated"), type: paramType(table.fields.find((f) => f.name === "updated")) }]),
         ];
         statements.push(({
             create: () => createCreateStoredProcedureOf(proc.name, quoted, columns, createdParams, key, keyType, writable, generatedKey, audit),
             read: () => createReadStoredProcedureOf(proc.name, quoted, columns, byParams, key, keyType, writable, by, generatedKey, audit),
             update: () => createUpdateStoredProcedureOf(proc.name, quoted, columns, updateParams, key, keyType, writable, by, generatedKey, audit),
             delete: () => createDeleteStoredProcedureOf(proc.name, quoted, columns, byParams, key, keyType, writable, by, generatedKey, audit),
-            bulkCreate: () => createBulkCreateStoredProcedureOf(proc.name, quoted, typedColumns, payload, key, keyType),
-            bulkUpdate: () => createBulkUpdateStoredProcedureOf(proc.name, quoted, typedColumns, payload, key, keyType),
+            bulkCreate: () => createBulkCreateStoredProcedureOf(proc.name, quoted, createColumns, payload, key, keyType),
+            bulkUpdate: () => createBulkUpdateStoredProcedureOf(proc.name, quoted, updateColumns, payload, key, keyType),
             bulkDelete: () => createBulkDeleteStoredProcedureOf(proc.name, quoted, typedColumns, payload, key, keyType),
         }[proc.op])());
     }

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/generate-sql.d.ts

@@ -1,5 +1,4 @@
 import type { GenerateContext } from "@deterministic-code/generators-common/generate-context";
 import { type GenerateEntry } from "@deterministic-code/generators-common/generate-entry";
 import { type SqlDialect } from "./sql-dialect.js";
-/** DDL initial migration (+ optional custom migrations and stored procedures) for one SQL dialect. */
 export declare const generateSqlFor: (dialect: SqlDialect, ctx: GenerateContext) => Promise<GenerateEntry[]>;

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/generate-sql.js

@@ -76,15 +76,29 @@ const loadSchema = async (ctx) => {
     };
 };
 /** DDL initial migration (+ optional custom migrations and stored procedures) for one SQL dialect. */
+const readerFor = async (dialect, ctx) => {
+    const named = `datasource.${dialect}.yaml`;
+    if (!(await ctx.reader.exists(named)))
+        return ctx;
+    const yaml = await ctx.reader.read(named);
+    return {
+        ...ctx,
+        reader: {
+            read: (name) => (name === "datasource.yaml" ? Promise.resolve(yaml) : ctx.reader.read(name)),
+            exists: (name) => (name === "datasource.yaml" ? Promise.resolve(true) : ctx.reader.exists(name)),
+        },
+    };
+};
 export const generateSqlFor = async (dialect, ctx) => {
     const key = requireDialect(dialect);
-    const casing = createCasing(ctx.settings);
-    const dir = ctx.settings["paths.deterministic"];
-    const schema = await schemaFiles(key, ctx, casing);
+    const scoped = await readerFor(key, ctx);
+    const casing = createCasing(scoped.settings);
+    const dir = scoped.settings["paths.deterministic"];
+    const schema = await schemaFiles(key, scoped, casing);
     return [
         ...schema.entries,
         ...(await customEntries(key, dir)),
-        ...(await generateProceduresForDialect(dialect, ctx, schema.count + 1)),
+        ...(await generateProceduresForDialect(dialect, scoped, schema.count + 1)),
     ];
 };
 const schemaFiles = async (key, ctx, casing) => {

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/procedures/helpers.d.ts

@@ -1,25 +1,22 @@
 /** Helpers shared by stored-procedure generation. */
-interface ProcField {
+export interface ProcField {
     name: string;
     type: string;
     size?: number;
+    includeInCreate?: boolean;
+    includeInUpdate?: boolean;
 }
-interface ProcTable {
+export interface ProcTable {
     fields: ProcField[];
     pkName?: string;
 }
 /** The entity's primary key: `pkName` when set, else a field named `id`. */
 export declare const pkFieldOf: (table: ProcTable) => ProcField;
-/** The writable, non-audit columns: everything but the pk, the system `uuid`, and `created`/`updated`. */
-export declare const writableNonAuditFields: (table: ProcTable) => ProcField[];
-/** CREATE IN-params from expanded columns, in the stored-procedure call order: `uuid` (if present), writable fields, `created`, `updated`. */
 export declare const createParamFields: (table: ProcTable) => ProcField[];
-/** The expanded `updated` column — present on every table that gets procedures. */
-export declare const updatedFieldOf: (table: ProcTable) => ProcField;
+export declare const updateParamFields: (table: ProcTable) => ProcField[];
 /** Expanded columns qualified with a table alias (default `t`). */
 export declare const aliasedColumns: (table: ProcTable, alias?: string, columnName?: (field: string) => string) => string;
 export declare const paramAlignWidth: (params: {
     name: string;
 }[]) => number;
 export declare const pad: (s: string, w: number) => string;
-export {};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/procedures/helpers.js

@@ -4,35 +4,8 @@ export const pkFieldOf = (table) => (table.pkName
     ? table.fields.find((f) => f.name === table.pkName)
     : undefined) ??
     table.fields.find((f) => f.name === "id") ?? { name: "id", type: "integer" };
-/** The writable, non-audit columns: everything but the pk, the system `uuid`, and `created`/`updated`. */
-export const writableNonAuditFields = (table) => {
-    const pk = pkFieldOf(table);
-    return table.fields.filter((f) => f.name !== pk.name &&
-        f.name !== "uuid" &&
-        f.name !== "created" &&
-        f.name !== "updated");
-};
-/** CREATE IN-params from expanded columns, in the stored-procedure call order: `uuid` (if present), writable fields, `created`, `updated`. */
-export const createParamFields = (table) => {
-    const field = (name) => {
-        const found = table.fields.find((f) => f.name === name);
-        return found ? [found] : [];
-    };
-    return [
-        ...field("uuid"),
-        ...writableNonAuditFields(table),
-        ...field("created"),
-        ...field("updated"),
-    ];
-};
-/** The expanded `updated` column — present on every table that gets procedures. */
-export const updatedFieldOf = (table) => {
-    const field = table.fields.find((f) => f.name === "updated");
-    if (!field) {
-        throw new Error("procedure table is missing expanded `updated` column");
-    }
-    return field;
-};
+export const createParamFields = (table) => table.fields.filter((f) => f.includeInCreate !== false);
+export const updateParamFields = (table) => table.fields.filter((f) => f.includeInUpdate === true);
 /** Expanded columns qualified with a table alias (default `t`). */
 export const aliasedColumns = (table, alias = "t", columnName = (field) => field) => table.fields.map((f) => `${alias}.${columnName(f.name)}`).join(", ");
 export const paramAlignWidth = (params) => params.reduce((m, p) => Math.max(m, p.name.length), 0);

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/seed-generator.js

@@ -4,7 +4,8 @@ import { sqlStringLiteral } from "@deterministic-code/datasources";
 import { identityInsertStatementOf, seedInsertStatementOf } from "../statements.js";
 import { renderSql, sqlDefault } from "./sql-dialect.js";
 import { dialectConverter } from "./sql-dialect.js";
-import { isGeneratedIdentity, overlayOf, tableIdentity, } from "./sql-schema.js";
+import { converterFieldOf } from "./converter-field.js";
+import { isGeneratedIdentity, overlayOf, tableIdentity, usesGeneratedIdColumn, } from "./sql-schema.js";
 const SEED_UUID_NAMESPACE = "9b3a8e6c-2f1d-4a5b-8c9d-1e2f3a4b5c6d";
 const pkType = (table) => table.fields.find((f) => isPkField(f, table, overlayOf(table)))?.type ??
     "integer";
@@ -63,8 +64,10 @@ export const seedSections = (dialect, tables, seeds, mapping) => {
         if (rows.length === 0)
             continue;
         const generated = isGeneratedIdentity(table) ? tableIdentity(table) : [];
-        const t = pkType(table);
-        const identity = isGeneratedIdentity(table) && t !== "uuid" && t !== "string";
+        const pk = table.fields.find((field) => field.name === tableIdentity(table)[0]);
+        const identity = pk != null &&
+            usesGeneratedIdColumn(table, pk) &&
+            sqlDefault(dialect, converterFieldOf(pk)) == null;
         const inserts = rows.map((seed) => {
             const cols = colsForRow(table, seed.row);
             const values = cols.map((c) => {

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/sql-dialect.d.ts

@@ -7,6 +7,7 @@ export type SqlGenerateDriver = IDriver & {
     defaultValueConverter: DefaultValueConverter;
     statementRenderer: StatementTextRenderer;
 };
+export declare const register: (dialect: string, driver: IDriver) => void;
 export declare const dialectDriver: (dialect: string) => SqlGenerateDriver;
 export declare const renderSql: (dialect: string, statement: IStatement) => string;
 export declare const dialectConverter: (dialect: string) => {

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/sql-dialect.js

@@ -1,16 +1,28 @@
-import { createRequire } from "node:module";
 import { DriverLoader, ProviderCatalog, } from "@deterministic-code/datasources";
-const require = createRequire(import.meta.url);
-export const dialectDriver = (dialect) => {
-    const catalog = ProviderCatalog.default[dialect];
-    if (catalog === undefined)
+const loaded = new Map();
+const named = (dialect) => ProviderCatalog.default[dialect] === undefined
+    ? (() => {
         throw new Error(`Unknown SQL dialect "${dialect}".`);
-    const driver = DriverLoader.load(new ProviderCatalog(catalog.name, require.resolve(catalog.location), catalog.module));
-    if (driver.typeConverter == null ||
-        driver.defaultValueConverter == null ||
-        driver.statementRenderer == null) {
+    })()
+    : dialect;
+const asGenerate = (dialect, driver) => driver.typeConverter == null ||
+    driver.defaultValueConverter == null ||
+    driver.statementRenderer == null
+    ? (() => {
         throw new Error(`"${dialect}" is not a SQL dialect.`);
-    }
+    })()
+    : driver;
+export const register = (dialect, driver) => {
+    loaded.set(named(dialect), asGenerate(dialect, driver));
+};
+export const dialectDriver = (dialect) => {
+    const key = named(dialect);
+    const hit = loaded.get(key);
+    if (hit !== undefined)
+        return hit;
+    const catalog = ProviderCatalog.default[key];
+    const driver = asGenerate(key, DriverLoader.load(catalog));
+    loaded.set(key, driver);
     return driver;
 };
 export const renderSql = (dialect, statement) => {

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/sql-schema.js

@@ -11,12 +11,15 @@ export const overlayOf = (table) => ({
     ...(table.mapping !== undefined ? { mapping: table.mapping } : {}),
 });
 export const fieldOverlay = (table, fieldName) => table.overlays.find((overlay) => overlay.name === fieldName);
-const GENERATED_ID_TYPES = new Set([
-    "integer",
-    "biginteger",
-    "uuid",
-    "string",
-]);
+const requireIdIsId = (spec) => {
+    for (const type of spec.types) {
+        for (const field of type.fields) {
+            if (field.name === "id" && field.isId !== true) {
+                throw new Error(`${type.name}.id must have is_id: true`);
+            }
+        }
+    }
+};
 export const tableIdentity = (table) => {
     const keys = identityColumns(table, overlayOf(table));
     if (keys.length > 1) {
@@ -38,10 +41,9 @@ export const isGeneratedIdentity = (table) => {
         return false;
     return fieldOverlay(table, keys[0])?.isFixedId !== true;
 };
-export const usesGeneratedIdColumn = (table, field) => isGeneratedIdentity(table) &&
-    field.name === tableIdentity(table)[0] &&
-    GENERATED_ID_TYPES.has(field.type);
+export const usesGeneratedIdColumn = (table, field) => field.isId === true && isGeneratedIdentity(table);
 export const sqlTablesFrom = (spec) => {
+    requireIdIsId(spec);
     const overlays = tableByName(spec);
     const byName = new Map(spec.expandedTypes.map((t) => [t.name, t]));
     return datasourceTypesOf(spec).map((type) => {

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/write-inclusion.d.ts

@@ -0,0 +1,9 @@
+import type { DatasourceFieldOverlay, TypeField } from "@deterministic-code/deterministic-generators-common/parser";
+export declare const resolveWriteInclusion: (create: boolean | undefined, update: boolean | undefined, identity: boolean, fixedId: boolean, singleGeneratedId: boolean) => {
+    includeInCreate: boolean;
+    includeInUpdate: boolean;
+};
+export declare const writeInclusionOf: (field: TypeField, ids: readonly string[], overlay?: DatasourceFieldOverlay) => {
+    includeInCreate: boolean;
+    includeInUpdate: boolean;
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/common/write-inclusion.js

@@ -0,0 +1,9 @@
+export const resolveWriteInclusion = (create, update, identity, fixedId, singleGeneratedId) => ({
+    includeInCreate: create ?? (!identity || fixedId || !singleGeneratedId),
+    includeInUpdate: update ?? (!identity || (!fixedId && !singleGeneratedId)),
+});
+export const writeInclusionOf = (field, ids, overlay) => {
+    const identity = ids.includes(field.name);
+    const fixedId = overlay?.isFixedId === true;
+    return resolveWriteInclusion(overlay?.includeInCreate, overlay?.includeInUpdate, identity, fixedId, identity && ids.length === 1 && !fixedId);
+};

package/node_modules/@deterministic-code/datasources-code-generators/dist/sql/statements.js

@@ -7,19 +7,14 @@ export const columnOf = (dialect, mapping, table, field) => {
     const overlay = fieldOverlay(table, field.name);
     const converterField = converterFieldOf(field);
     const generated = usesGeneratedIdColumn(table, field);
-    const identity = generated && field.type !== "uuid" && field.type !== "string";
     const named = mapping.constraintName(table, mapping.fieldStem(table, field.name), "default_constraint");
-    const utcNow = dialectDriver(dialect).defaultValueConverter.convert("datetime", "UtcNow");
-    const newId = dialectDriver(dialect).defaultValueConverter.convert("uuid", "NewId");
     const fromSpec = sqlDefault(dialect, converterField);
-    const defaultExpr = fromSpec ??
-        (field.name === "created" || field.name === "updated" ? utcNow : null) ??
-        (field.name === "uuid" || (generated && field.type === "uuid") ? newId : null);
+    const identity = generated && fromSpec == null;
     const keys = tableIdentity(table);
     return {
         name: q(dialect, mapping.columnName(table, field.name)),
         type: mapColumnType(dialect, converterField),
-        ...(defaultExpr ? { default: new ColumnDefault(defaultExpr, q(dialect, named)) } : {}),
+        ...(fromSpec ? { default: new ColumnDefault(fromSpec, q(dialect, named)) } : {}),
         ...(!field.isNullable || keys.includes(field.name) ? { notNull: new NotNull() } : {}),
         ...(identity ? { identity: true } : {}),
     };

package/node_modules/@deterministic-code/datasources-code-generators/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@deterministic-code/datasources-code-generators",
-  "version": "0.1.2",
+  "version": "0.1.11",
   "type": "module",
   "exports": {
     ".": "./dist/generateSql.js",
     "./generate-sql": "./dist/generate-sql.js",
+    "./sql/generate-sql": "./dist/sql/generate-sql.js",
     "./generate-stored-procedures": "./dist/generate-stored-procedures.js",
+    "./sql/generate-stored-procedures": "./dist/sql/generate-stored-procedures.js",
     "./common/sql-dialect": "./dist/sql/common/sql-dialect.js",
-    "./sql/dialect-converters": "./dist/sql/dialect-converters.js"
+    "./sql/common/write-inclusion": "./dist/sql/common/write-inclusion.js"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.6",
-    "@deterministic-code/datasources-mysql": "^0.1.6",
-    "@deterministic-code/datasources-oracle": "^0.1.6",
-    "@deterministic-code/datasources-postgres": "^0.1.6",
-    "@deterministic-code/datasources-sqlite": "^0.1.6",
-    "@deterministic-code/datasources-sqlserver": "^0.1.6",
+    "@deterministic-code/datasources": "^0.1.11",
+    "@deterministic-code/datasources-mysql": "^0.1.11",
+    "@deterministic-code/datasources-oracle": "^0.1.11",
+    "@deterministic-code/datasources-postgres": "^0.1.11",
+    "@deterministic-code/datasources-sqlite": "^0.1.11",
+    "@deterministic-code/datasources-sqlserver": "^0.1.11",
     "@deterministic-code/deterministic-generators-common": "0.1.0",
     "@deterministic-code/generators-common": "0.0.1",
     "pluralize": "^8.0.0",

package/node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/dist/specification-parser.js

@@ -557,6 +557,65 @@ var inheritsChain = (name, typeByName) => {
   }
   return chain;
 };
+var firstAuthoredInclusion = (walk, overlays, field, key) => {
+  for (const typeName of walk) {
+    const value = overlays.get(typeName)?.get(field)?.[key];
+    if (value !== void 0) return value;
+  }
+  return void 0;
+};
+var mergeWriteInclusion = (tables, types, authored) => {
+  const typeByName = new Map(types.map((type) => [type.name, type]));
+  const overlays = new Map(
+    authored.map((table) => [
+      table.name,
+      new Map(table.fields.map((field) => [field.name, field]))
+    ])
+  );
+  return tables.map((table) => {
+    const walk = [table.name, ...inheritsChain(table.name, typeByName)];
+    const names = [];
+    const seen = /* @__PURE__ */ new Set();
+    const add = (name) => {
+      if (seen.has(name)) return;
+      seen.add(name);
+      names.push(name);
+    };
+    for (const field of typeByName.get(table.name)?.fields ?? []) add(field.name);
+    for (const field of table.fields) add(field.name);
+    const fields = table.fields.map((field) => ({ ...field }));
+    const byName = new Map(fields.map((field) => [field.name, field]));
+    for (const name of names) {
+      const includeInCreate = firstAuthoredInclusion(
+        walk,
+        overlays,
+        name,
+        "includeInCreate"
+      );
+      const includeInUpdate = firstAuthoredInclusion(
+        walk,
+        overlays,
+        name,
+        "includeInUpdate"
+      );
+      if (includeInCreate === void 0 && includeInUpdate === void 0) continue;
+      const existing = byName.get(name);
+      if (existing) {
+        if (includeInCreate !== void 0) existing.includeInCreate = includeInCreate;
+        if (includeInUpdate !== void 0) existing.includeInUpdate = includeInUpdate;
+      } else {
+        const created = {
+          name,
+          ...includeInCreate !== void 0 ? { includeInCreate } : {},
+          ...includeInUpdate !== void 0 ? { includeInUpdate } : {}
+        };
+        fields.push(created);
+        byName.set(name, created);
+      }
+    }
+    return { ...table, fields };
+  });
+};
 var parseSeedKey = (rowKey) => {
   const m = /^id(\d+)$/.exec(rowKey);
   if (!m) {
@@ -738,6 +797,8 @@ var Parser = class {
         ...fnode.has("is_unique") ? { isUnique: fnode.bool("is_unique") } : {},
         ...fnode.str("mapping") ? { mapping: fnode.str("mapping") } : {},
         ...fnode.has("is_fixed_id") ? { isFixedId: fnode.bool("is_fixed_id") } : {},
+        ...fnode.has("include_in_create") ? { includeInCreate: fnode.bool("include_in_create") } : {},
+        ...fnode.has("include_in_update") ? { includeInUpdate: fnode.bool("include_in_update") } : {},
         ...fnode.has("is_optimistic_concurrency") ? {
           isOptimisticConcurrency: fnode.bool(
             "is_optimistic_concurrency"
@@ -759,7 +820,7 @@ var Parser = class {
       };
     });
     const filter = this.#typesFilter(root);
-    if (!filter) return tables;
+    if (!filter) return mergeWriteInclusion(tables, types, tables);
     const selected = new Set(
       types.filter((t) => filter(t)).map((t) => t.name)
     );
@@ -772,7 +833,11 @@ var Parser = class {
         uniqueIndexFields: []
       })
     );
-    return [...tables.filter((t) => selected.has(t.name)), ...extras];
+    return mergeWriteInclusion(
+      [...tables.filter((t) => selected.has(t.name)), ...extras],
+      types,
+      tables
+    );
   }
   #parseDatasourceSeeds(yaml) {
     const byTable = /* @__PURE__ */ new Map();

package/node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/parser/specification-parser.ts

@@ -97,6 +97,76 @@ export const inheritsChain = (
   return chain;
 };
 
+const firstAuthoredInclusion = (
+  walk: string[],
+  overlays: Map<string, Map<string, DatasourceFieldOverlay>>,
+  field: string,
+  key: "includeInCreate" | "includeInUpdate",
+): boolean | undefined => {
+  for (const typeName of walk) {
+    const value = overlays.get(typeName)?.get(field)?.[key];
+    if (value !== undefined) return value;
+  }
+  return undefined;
+};
+
+const mergeWriteInclusion = (
+  tables: DatasourceTable[],
+  types: Type[],
+  authored: DatasourceTable[],
+): DatasourceTable[] => {
+  const typeByName = new Map(types.map((type) => [type.name, type]));
+  const overlays = new Map(
+    authored.map((table) => [
+      table.name,
+      new Map(table.fields.map((field) => [field.name, field])),
+    ]),
+  );
+  return tables.map((table) => {
+    const walk = [table.name, ...inheritsChain(table.name, typeByName)];
+    const names: string[] = [];
+    const seen = new Set<string>();
+    const add = (name: string) => {
+      if (seen.has(name)) return;
+      seen.add(name);
+      names.push(name);
+    };
+    for (const field of typeByName.get(table.name)?.fields ?? []) add(field.name);
+    for (const field of table.fields) add(field.name);
+    const fields = table.fields.map((field) => ({ ...field }));
+    const byName = new Map(fields.map((field) => [field.name, field]));
+    for (const name of names) {
+      const includeInCreate = firstAuthoredInclusion(
+        walk,
+        overlays,
+        name,
+        "includeInCreate",
+      );
+      const includeInUpdate = firstAuthoredInclusion(
+        walk,
+        overlays,
+        name,
+        "includeInUpdate",
+      );
+      if (includeInCreate === undefined && includeInUpdate === undefined) continue;
+      const existing = byName.get(name);
+      if (existing) {
+        if (includeInCreate !== undefined) existing.includeInCreate = includeInCreate;
+        if (includeInUpdate !== undefined) existing.includeInUpdate = includeInUpdate;
+      } else {
+        const created: DatasourceFieldOverlay = {
+          name,
+          ...(includeInCreate !== undefined ? { includeInCreate } : {}),
+          ...(includeInUpdate !== undefined ? { includeInUpdate } : {}),
+        };
+        fields.push(created);
+        byName.set(name, created);
+      }
+    }
+    return { ...table, fields };
+  });
+};
+
 const parseSeedKey = (rowKey: string): number => {
   const m = /^id(\d+)$/.exec(rowKey);
   if (!m) {
@@ -339,6 +409,12 @@ class Parser {
           ...(fnode.has("is_fixed_id")
             ? { isFixedId: fnode.bool("is_fixed_id") }
             : {}),
+          ...(fnode.has("include_in_create")
+            ? { includeInCreate: fnode.bool("include_in_create") }
+            : {}),
+          ...(fnode.has("include_in_update")
+            ? { includeInUpdate: fnode.bool("include_in_update") }
+            : {}),
           ...(fnode.has("is_optimistic_concurrency")
             ? {
                 isOptimisticConcurrency: fnode.bool(
@@ -367,7 +443,7 @@ class Parser {
     });
 
     const filter = this.#typesFilter(root);
-    if (!filter) return tables;
+    if (!filter) return mergeWriteInclusion(tables, types, tables);
     const selected = new Set(
       types.filter((t) => filter(t)).map((t) => t.name),
     );
@@ -382,7 +458,11 @@ class Parser {
           uniqueIndexFields: [],
         }),
       );
-    return [...tables.filter((t) => selected.has(t.name)), ...extras];
+    return mergeWriteInclusion(
+      [...tables.filter((t) => selected.has(t.name)), ...extras],
+      types,
+      tables,
+    );
   }
 
   #parseDatasourceSeeds(yaml: string): Map<string, SeedRow[]> {

package/node_modules/@deterministic-code/deterministic-generators-common/typescript/parser/specification.ts

@@ -46,6 +46,8 @@ export type DatasourceFieldOverlay = {
   isUnique?: boolean;
   mapping?: string;
   isFixedId?: boolean;
+  includeInCreate?: boolean;
+  includeInUpdate?: boolean;
   isOptimisticConcurrency?: boolean;
   useNativeRowVersion?: boolean;
 };

package/node_modules/@deterministic-code/deterministic-specifications-typescript/typescript/parser/parser/specification-parser.ts

@@ -96,6 +96,76 @@ export const inheritsChain = (
   return chain;
 };
 
+const firstAuthoredInclusion = (
+  walk: string[],
+  overlays: Map<string, Map<string, DatasourceFieldOverlay>>,
+  field: string,
+  key: "includeInCreate" | "includeInUpdate",
+): boolean | undefined => {
+  for (const typeName of walk) {
+    const value = overlays.get(typeName)?.get(field)?.[key];
+    if (value !== undefined) return value;
+  }
+  return undefined;
+};
+
+const mergeWriteInclusion = (
+  tables: DatasourceTable[],
+  types: Type[],
+  authored: DatasourceTable[],
+): DatasourceTable[] => {
+  const typeByName = new Map(types.map((type) => [type.name, type]));
+  const overlays = new Map(
+    authored.map((table) => [
+      table.name,
+      new Map(table.fields.map((field) => [field.name, field])),
+    ]),
+  );
+  return tables.map((table) => {
+    const walk = [table.name, ...inheritsChain(table.name, typeByName)];
+    const names: string[] = [];
+    const seen = new Set<string>();
+    const add = (name: string) => {
+      if (seen.has(name)) return;
+      seen.add(name);
+      names.push(name);
+    };
+    for (const field of typeByName.get(table.name)?.fields ?? []) add(field.name);
+    for (const field of table.fields) add(field.name);
+    const fields = table.fields.map((field) => ({ ...field }));
+    const byName = new Map(fields.map((field) => [field.name, field]));
+    for (const name of names) {
+      const includeInCreate = firstAuthoredInclusion(
+        walk,
+        overlays,
+        name,
+        "includeInCreate",
+      );
+      const includeInUpdate = firstAuthoredInclusion(
+        walk,
+        overlays,
+        name,
+        "includeInUpdate",
+      );
+      if (includeInCreate === undefined && includeInUpdate === undefined) continue;
+      const existing = byName.get(name);
+      if (existing) {
+        if (includeInCreate !== undefined) existing.includeInCreate = includeInCreate;
+        if (includeInUpdate !== undefined) existing.includeInUpdate = includeInUpdate;
+      } else {
+        const created: DatasourceFieldOverlay = {
+          name,
+          ...(includeInCreate !== undefined ? { includeInCreate } : {}),
+          ...(includeInUpdate !== undefined ? { includeInUpdate } : {}),
+        };
+        fields.push(created);
+        byName.set(name, created);
+      }
+    }
+    return { ...table, fields };
+  });
+};
+
 const parseSeedKey = (rowKey: string): number => {
   const m = /^id(\d+)$/.exec(rowKey);
   if (!m) {
@@ -338,6 +408,12 @@ class Parser {
           ...(fnode.has("is_fixed_id")
             ? { isFixedId: fnode.bool("is_fixed_id") }
             : {}),
+          ...(fnode.has("include_in_create")
+            ? { includeInCreate: fnode.bool("include_in_create") }
+            : {}),
+          ...(fnode.has("include_in_update")
+            ? { includeInUpdate: fnode.bool("include_in_update") }
+            : {}),
           ...(fnode.has("is_optimistic_concurrency")
             ? {
                 isOptimisticConcurrency: fnode.bool(
@@ -366,7 +442,7 @@ class Parser {
     });
 
     const filter = this.#typesFilter(root);
-    if (!filter) return tables;
+    if (!filter) return mergeWriteInclusion(tables, types, tables);
     const selected = new Set(
       types.filter((t) => filter(t)).map((t) => t.name),
     );
@@ -381,7 +457,11 @@ class Parser {
           uniqueIndexFields: [],
         }),
       );
-    return [...tables.filter((t) => selected.has(t.name)), ...extras];
+    return mergeWriteInclusion(
+      [...tables.filter((t) => selected.has(t.name)), ...extras],
+      types,
+      tables,
+    );
   }
 
   #parseDatasourceSeeds(yaml: string): Map<string, SeedRow[]> {

package/node_modules/@deterministic-code/deterministic-specifications-typescript/typescript/parser/specification.ts

@@ -46,6 +46,8 @@ export type DatasourceFieldOverlay = {
   isUnique?: boolean;
   mapping?: string;
   isFixedId?: boolean;
+  includeInCreate?: boolean;
+  includeInUpdate?: boolean;
   isOptimisticConcurrency?: boolean;
   useNativeRowVersion?: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "bin": {
     "datasources": "./bin/datasources.mjs"
@@ -13,7 +13,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@deterministic-code/datasources-code-generators": "0.1.2",
+    "@deterministic-code/datasources-code-generators": "0.1.11",
     "@deterministic-code/generators-common": "0.0.1",
     "@deterministic-code/deterministic-generators-common": "0.1.0",
     "@deterministic-code/typescript-generators": "0.0.1",
@@ -21,12 +21,12 @@
     "@deterministic-code/rust-generators": "0.0.1",
     "@deterministic-code/generators-openapi": "0.0.1",
     "@deterministic-code/patch-merger": "0.1.0",
-    "@deterministic-code/datasources": "^0.1.6",
-    "@deterministic-code/datasources-sqlite": "^0.1.6",
-    "@deterministic-code/datasources-mysql": "^0.1.6",
-    "@deterministic-code/datasources-postgres": "^0.1.6",
-    "@deterministic-code/datasources-sqlserver": "^0.1.6",
-    "@deterministic-code/datasources-oracle": "^0.1.6",
+    "@deterministic-code/datasources": "^0.1.11",
+    "@deterministic-code/datasources-sqlite": "^0.1.11",
+    "@deterministic-code/datasources-mysql": "^0.1.11",
+    "@deterministic-code/datasources-postgres": "^0.1.11",
+    "@deterministic-code/datasources-sqlserver": "^0.1.11",
+    "@deterministic-code/datasources-oracle": "^0.1.11",
     "@inquirer/prompts": "^7.8.0",
     "yaml": "^2.6.0",
     "mustache": "^4.2.0",