@deterministic-code/datasources-cli 0.1.10 → 0.1.12

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.12",
   "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.12",
+    "@deterministic-code/datasources-mysql": "^0.1.12",
+    "@deterministic-code/datasources-oracle": "^0.1.12",
+    "@deterministic-code/datasources-postgres": "^0.1.12",
+    "@deterministic-code/datasources-sqlite": "^0.1.12",
+    "@deterministic-code/datasources-sqlserver": "^0.1.12",
     "@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.12",
   "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.12",
     "@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.12",
+    "@deterministic-code/datasources-sqlite": "^0.1.12",
+    "@deterministic-code/datasources-mysql": "^0.1.12",
+    "@deterministic-code/datasources-postgres": "^0.1.12",
+    "@deterministic-code/datasources-sqlserver": "^0.1.12",
+    "@deterministic-code/datasources-oracle": "^0.1.12",
     "@inquirer/prompts": "^7.8.0",
     "yaml": "^2.6.0",
     "mustache": "^4.2.0",