@deterministic-code/datasources-cli 0.1.10 → 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/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/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/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,
@@ -21,7 +16,7 @@ import { applyMigrateUp } from "./generate/migrateUp.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);

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-code-generators",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "exports": {
     ".": "./dist/generateSql.js",
@@ -8,15 +8,16 @@
     "./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"
+    "./common/sql-dialect": "./dist/sql/common/sql-dialect.js",
+    "./sql/common/write-inclusion": "./dist/sql/common/write-inclusion.js"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.10",
-    "@deterministic-code/datasources-mysql": "^0.1.10",
-    "@deterministic-code/datasources-oracle": "^0.1.10",
-    "@deterministic-code/datasources-postgres": "^0.1.10",
-    "@deterministic-code/datasources-sqlite": "^0.1.10",
-    "@deterministic-code/datasources-sqlserver": "^0.1.10",
+    "@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.10",
+  "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.10",
+    "@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.10",
-    "@deterministic-code/datasources-sqlite": "^0.1.10",
-    "@deterministic-code/datasources-mysql": "^0.1.10",
-    "@deterministic-code/datasources-postgres": "^0.1.10",
-    "@deterministic-code/datasources-sqlserver": "^0.1.10",
-    "@deterministic-code/datasources-oracle": "^0.1.10",
+    "@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",