@wictorwilen/cocogen 1.0.17 → 1.0.18

package/dist/init/templates/dotnet/Generated/FromRow.cs.ejs

@@ -0,0 +1,23 @@
+// Map source rows into the schema model.
+using System.Collections.Generic;
+using <%= namespaceName %>;
+using <%= namespaceName %>.Datasource;
+
+namespace <%= schemaNamespace %>;
+
+/// <summary>
+/// Maps source rows into the schema model using generated transforms.
+/// </summary>
+public static class FromRow
+{
+    /// <summary>
+    /// Convert a row dictionary into a schema model instance.
+    /// </summary>
+    public static <%= itemTypeName %> Parse(IReadOnlyDictionary<string, string?> row)
+    {
+        var transforms = new PropertyTransform();
+        return new <%= itemTypeName %>(
+<%- constructorArgLines %>
+        );
+    }
+}

package/dist/init/templates/dotnet/Generated/Model.cs.ejs

@@ -1,12 +1,16 @@
 // C# representation of the external item schema.
 namespace <%= schemaNamespace %>;
 
+<% if (recordDocLines && recordDocLines.length) { -%>
+<%- recordDocLines.join("\n") %>
+<% } else { -%>
 /// <summary>
 /// Schema model generated from TypeSpec.
 /// </summary>
+<% } -%>
 public sealed record <%= itemTypeName %>(
 <% for (let i = 0; i < properties.length; i++) { -%>
     <%= properties[i].csType %> <%= properties[i].csName %>,
 <% } -%>
-    string CocoId = ""
+    string InternalId = ""
 );

package/dist/init/templates/dotnet/Generated/PropertyTransformBase.cs.ejs

@@ -5,12 +5,13 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
 <% } -%>
+using <%= namespaceName %>.Core;
 using <%= namespaceName %>.Datasource;
 
 namespace <%= schemaNamespace %>;
 
 /// <summary>
-/// Base class for CSV-to-model property transforms.
+/// Base class for row-to-model property transforms.
 /// </summary>
 public abstract class PropertyTransformBase
 {
@@ -30,16 +31,29 @@ public abstract class PropertyTransformBase
 
 <% for (const prop of properties) { -%>
     /// <summary>
-    /// Transform the <%= prop.name %> property from a CSV row.
+    /// Transform the <%= prop.name %> property from a source row.
     /// </summary>
     protected virtual <%= prop.csType %> Transform<%= prop.csName %>(IReadOnlyDictionary<string, string?> row)
     {
-    <% if (prop.transformThrows) { -%>
+<%_ if (prop.transformThrows) { -%>
         <%- prop.transformExpression %>;
-    <% } else { -%>
+<%_ } else { -%>
         return <%- prop.transformExpression %>;
-    <% } -%>
+<%_ } -%>
     }
 
 <% } -%>
+
+    private static List<DateTimeOffset> ValidateDateTimeCollection(string name, string raw, int? minLength, int? maxLength, string? pattern, string? format)
+    {
+        var parts = RowParser.ParseStringCollection(raw);
+        if (parts.Count == 0) return new List<DateTimeOffset>();
+        var results = new List<DateTimeOffset>(parts.Count);
+        for (var index = 0; index < parts.Count; index++)
+        {
+            var validated = Validation.ValidateString(name, parts[index], minLength, maxLength, pattern, format);
+            results.Add(RowParser.ParseDateTime(validated));
+        }
+        return results;
+    }
 }

package/dist/init/templates/dotnet/Generated/RowParser.cs.ejs

@@ -0,0 +1,184 @@
+// Row value parsing helpers used by generated transforms.
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace <%= namespaceName %>.Datasource;
+
+/// <summary>
+/// Helpers for parsing typed values from row dictionaries.
+/// </summary>
+public static class RowParser
+{
+    /// <summary>
+    /// Read the first matching header value from the row.
+    /// </summary>
+    public static string ReadValue(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        if (headers.Length == 0) return "";
+        return row.TryGetValue(headers[0], out var v) ? (v ?? "") : "";
+    }
+
+    /// <summary>
+    /// Parse a nullable string value into a string.
+    /// </summary>
+    public static string ParseString(string? value)
+    {
+        return value ?? "";
+    }
+
+    /// <summary>
+    /// Parse a string from a row using the provided headers.
+    /// </summary>
+    public static string ParseString(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseString(ReadValue(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a boolean from a row using the provided headers.
+    /// </summary>
+    public static bool ParseBoolean(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseBoolean(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a boolean from a string value.
+    /// </summary>
+    public static bool ParseBoolean(string? value)
+    {
+        var v = ParseString(value);
+        return v.Equals("true", StringComparison.OrdinalIgnoreCase) || v.Equals("1");
+    }
+
+    /// <summary>
+    /// Parse an Int64 from a row using the provided headers.
+    /// </summary>
+    public static long ParseInt64(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseInt64(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse an Int64 from a string value.
+    /// </summary>
+    public static long ParseInt64(string? value)
+    {
+        var v = ParseString(value);
+        return long.TryParse(v, out var n) ? n : 0;
+    }
+
+    /// <summary>
+    /// Parse a double from a row using the provided headers.
+    /// </summary>
+    public static double ParseDouble(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseDouble(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a double from a string value.
+    /// </summary>
+    public static double ParseDouble(string? value)
+    {
+        var v = ParseString(value);
+        return double.TryParse(v, out var n) ? n : 0;
+    }
+
+    /// <summary>
+    /// Parse a DateTimeOffset from a row using the provided headers.
+    /// </summary>
+    public static DateTimeOffset ParseDateTime(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseDateTime(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a DateTimeOffset from a string value.
+    /// </summary>
+    public static DateTimeOffset ParseDateTime(string? value)
+    {
+        var v = ParseString(value);
+        return DateTimeOffset.TryParse(v, out var dt) ? dt : DateTimeOffset.MinValue;
+    }
+
+    /// <summary>
+    /// Parse a string collection from a row using the provided headers.
+    /// </summary>
+    public static List<string> ParseStringCollection(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseStringCollection(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a string collection from a string value.
+    /// </summary>
+    public static List<string> ParseStringCollection(string? value)
+    {
+        var v = ParseString(value);
+        return v.Length == 0
+            ? new List<string>()
+            : v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToList();
+    }
+
+    /// <summary>
+    /// Parse an Int64 collection from a row using the provided headers.
+    /// </summary>
+    public static List<long> ParseInt64Collection(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseInt64Collection(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse an Int64 collection from a string value.
+    /// </summary>
+    public static List<long> ParseInt64Collection(string? value)
+    {
+        var v = ParseString(value);
+        if (v.Length == 0) return new List<long>();
+        return v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Select((x) => long.TryParse(x, out var n) ? n : 0)
+            .ToList();
+    }
+
+    /// <summary>
+    /// Parse a double collection from a row using the provided headers.
+    /// </summary>
+    public static List<double> ParseDoubleCollection(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseDoubleCollection(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a double collection from a string value.
+    /// </summary>
+    public static List<double> ParseDoubleCollection(string? value)
+    {
+        var v = ParseString(value);
+        if (v.Length == 0) return new List<double>();
+        return v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Select((x) => double.TryParse(x, out var n) ? n : 0)
+            .ToList();
+    }
+
+    /// <summary>
+    /// Parse a DateTimeOffset collection from a row using the provided headers.
+    /// </summary>
+    public static List<DateTimeOffset> ParseDateTimeCollection(IReadOnlyDictionary<string, string?> row, string[] headers)
+    {
+        return ParseDateTimeCollection(ParseString(row, headers));
+    }
+
+    /// <summary>
+    /// Parse a DateTimeOffset collection from a string value.
+    /// </summary>
+    public static List<DateTimeOffset> ParseDateTimeCollection(string? value)
+    {
+        var v = ParseString(value);
+        if (v.Length == 0) return new List<DateTimeOffset>();
+        return v.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Select((x) => DateTimeOffset.TryParse(x, out var dt) ? dt : DateTimeOffset.MinValue)
+            .ToList();
+    }
+}

package/dist/init/templates/dotnet/Program.commandline.cs.ejs

@@ -167,7 +167,7 @@ async Task ProvisionAsync()
 /// <summary>
 /// Ingest items from CSV.
 /// </summary>
-async Task IngestAsync(string? csvPath, bool dryRun, int? limit, bool verbose)
+async Task IngestAsync(string? csvPath, bool dryRun, int? limit, bool verbose, bool failFast)
 {
     GraphServiceClient? graph = null;
     TokenCredential? credential = null;
@@ -186,7 +186,7 @@ async Task IngestAsync(string? csvPath, bool dryRun, int? limit, bool verbose)
     IItemSource source = new CsvItemSource(path);
     var core = BuildConnectorCore(graph, credential, connectionId);
 
-    await core.IngestAsync(source, dryRun, limit, verbose);
+    await core.IngestAsync(source, dryRun, limit, verbose, failFast);
 }
 
 /// <summary>
@@ -205,6 +205,7 @@ async Task DeleteConnectionAsync()
 
 var csvOption = new Option<string>("--csv", description: "CSV path");
 var dryRunOption = new Option<bool>("--dry-run", description: "Build payloads but do not send to Graph");
+var failFastOption = new Option<bool>("--fail-fast", description: "Abort on the first item failure");
 var limitOption = new Option<int?>("--limit", description: "Limit number of items");
 var verboseOption = new Option<bool>("--verbose", description: "Print payloads sent to Graph");
 
@@ -216,12 +217,14 @@ provisionCommand.SetHandler(async () => await ProvisionAsync());
 var ingestCommand = new Command("ingest", "Ingest items from CSV");
 ingestCommand.AddOption(csvOption);
 ingestCommand.AddOption(dryRunOption);
+ingestCommand.AddOption(failFastOption);
 ingestCommand.AddOption(limitOption);
 ingestCommand.AddOption(verboseOption);
 ingestCommand.SetHandler(
-    async (string? csv, bool dryRun, int? limit, bool verbose) => await IngestAsync(csv, dryRun, limit, verbose),
+    async (string? csv, bool dryRun, bool failFast, int? limit, bool verbose) => await IngestAsync(csv, dryRun, limit, verbose, failFast),
     csvOption,
     dryRunOption,
+    failFastOption,
     limitOption,
     verboseOption
 );

package/dist/init/templates/dotnet/PropertyTransform.cs.ejs

@@ -1,4 +1,4 @@
-// Customize CSV-to-model property transforms.
+// Customize row-to-model property transforms.
 namespace <%= schemaNamespace %>;
 
 /// <summary>

package/dist/init/templates/dotnet/README.md.ejs

@@ -53,6 +53,7 @@ Run `npm install` in this folder to fetch the TypeSpec library.
 ## Ingest debugging flags
 Use `dotnet run -- ingest` with:
 - `--dry-run` (build payloads without sending)
+- `--fail-fast` (abort on the first item failure)
 - `--limit <n>` (ingest only N items)
 - `--verbose` (print the exact payload sent to Graph)
 
@@ -60,7 +61,7 @@ Note: `--dry-run` does not require Azure AD or connection settings.
 
 ## Switching from CSV to another datasource
 1) Implement `IItemSource` in `Datasource/`.
-2) If your source yields raw records, map them to `<%= itemTypeName %>` using `FromCsvRow`-style logic.
+2) If your source yields raw records, map them to `<%= itemTypeName %>` using `FromRow`-style logic.
 3) Update `Program.cs` to instantiate your new source instead of `CsvItemSource`.
 
 Tip: keep the `IAsyncEnumerable<<%= itemTypeName %>>` pattern for large datasets.

package/dist/init/templates/ts/README.md.ejs

@@ -42,6 +42,7 @@ Run `npm install` to fetch the TypeSpec library.
 ## Ingest debugging flags
 Use `npm run ingest --` with:
 - `--dry-run` (build payloads without sending)
+- `--fail-fast` (abort on the first item failure)
 - `--limit <n>` (ingest only N items)
 - `--verbose` (print the exact payload sent to Graph)
 
@@ -49,7 +50,7 @@ Note: `--dry-run` does not require CONNECTION_ID, but you still need it for real
 
 ## Switching from CSV to another datasource
 1) Implement `ItemSource` in `src/datasource`.
-2) If your source yields raw records, map them to `<%= itemTypeName %>` using `fromCsvRow`-style logic.
+2) If your source yields raw records, map them to `<%= itemTypeName %>` using `fromRow`-style logic.
 3) Update `src/cli.ts` to instantiate your new source instead of `CsvItemSource`.
 
 Tip: keep the streaming `AsyncIterable<<%= itemTypeName %>>` pattern for large datasets.

package/dist/init/templates/ts/src/cli.ts.ejs

@@ -172,6 +172,7 @@ async function ingest(options: {
   dryRun?: boolean;
   limit?: number;
   verbose?: boolean;
+  failFast?: boolean;
 }): Promise<void> {
   const connectionId = options.dryRun ? "dry-run" : resolveConnectionId();
   // Swap this for any ItemSource implementation (API, DB, queue, etc.).
@@ -183,6 +184,7 @@ async function ingest(options: {
     dryRun: options.dryRun,
     limit: options.limit,
     verbose: options.verbose,
+    failFast: options.failFast,
     toExternalItem
   });
 }
@@ -200,12 +202,14 @@ program
   .description("Ingest items from CSV")
   .option("--csv <path>", "CSV path")
   .option("--dry-run", "Build payloads but do not send to Graph")
+  .option("--fail-fast", "Abort on the first item failure")
   .option("--limit <n>", "Limit number of items", (value) => Number(value))
   .option("--verbose", "Print payloads sent to Graph")
-  .action((options: { csv?: string; dryRun?: boolean; limit?: number; verbose?: boolean }) =>
+  .action((options: { csv?: string; dryRun?: boolean; limit?: number; verbose?: boolean; failFast?: boolean }) =>
     ingest({
       csvPath: options.csv,
       dryRun: options.dryRun,
+      failFast: options.failFast,
       limit: options.limit,
       verbose: options.verbose,
     })

package/dist/init/templates/ts/src/core/connectorCore.ts.ejs

@@ -33,6 +33,7 @@ export type IngestOptions<Item> = {
   dryRun?: boolean;
   limit?: number;
   verbose?: boolean;
+  failFast?: boolean;
   toExternalItem: (item: Item) => unknown;
 };
 
@@ -178,6 +179,8 @@ export class ConnectorCore<Item> {
    */
   async ingest(options: IngestOptions<Item>): Promise<void> {
     let count = 0;
+    let successCount = 0;
+    const failures: Array<{ index: number; id: string; message: string }> = [];
     for await (const item of options.source.getItems()) {
       if (options.limit && count >= options.limit) break;
       const itemId = this.getItemId(item as Item);
@@ -186,9 +189,14 @@ export class ConnectorCore<Item> {
         try {
           await this.putItem(options.connectionId, item as Item, Boolean(options.verbose));
           console.log(`ok: ingested item ${count + 1} (id=${itemId})`);
+          successCount++;
         } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
           console.error(`error: failed item ${count + 1} (id=${itemId})`);
-          throw error;
+          failures.push({ index: count + 1, id: itemId, message });
+          if (options.failFast) {
+            throw error;
+          }
         }
       } else if (options.verbose) {
         const payload = options.toExternalItem(item as Item) as any;
@@ -202,7 +210,18 @@ export class ConnectorCore<Item> {
       count++;
     }
 
-    console.log("ok: ingested " + count + " item(s)");
+    if (!options.dryRun) {
+      console.log(`ok: ingested ${successCount} item(s)`);
+    } else {
+      console.log(`ok: inspected ${count} item(s)`);
+    }
+
+    if (failures.length > 0) {
+      console.warn(`warn: ${failures.length} item(s) failed`);
+      for (const failure of failures) {
+        console.warn(`warn: failed item ${failure.index} (id=${failure.id}) - ${failure.message}`);
+      }
+    }
   }
 
   private async graphRequest(method: string, url: string, body?: unknown): Promise<Response> {

package/dist/init/templates/ts/src/core/validation.ts.ejs

@@ -0,0 +1,89 @@
+type StringConstraints = {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: string;
+  format?: string;
+};
+
+type NumberConstraints = {
+  minValue?: number;
+  maxValue?: number;
+};
+
+function validateFormat(name: string, value: string, format?: string): void {
+  if (!format || !value) return;
+  const normalized = format.toLowerCase();
+  if (normalized === "email") {
+    if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value)) {
+      throw new Error(`Invalid ${name}: expected email format.`);
+    }
+    return;
+  }
+  if (normalized === "uri" || normalized === "url") {
+    try {
+      new URL(value);
+    } catch {
+      throw new Error(`Invalid ${name}: expected URI format.`);
+    }
+    return;
+  }
+  if (normalized === "uuid") {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+      throw new Error(`Invalid ${name}: expected UUID format.`);
+    }
+    return;
+  }
+  if (normalized === "date-time") {
+    const time = Date.parse(value);
+    if (Number.isNaN(time)) {
+      throw new Error(`Invalid ${name}: expected date-time format.`);
+    }
+  }
+}
+
+function validateString(name: string, value: string, constraints?: StringConstraints): string {
+  if (!constraints) return value;
+  const length = value.length;
+  if (constraints.minLength !== undefined && length < constraints.minLength) {
+    throw new Error(`Invalid ${name}: minimum length is ${constraints.minLength}.`);
+  }
+  if (constraints.maxLength !== undefined && length > constraints.maxLength) {
+    throw new Error(`Invalid ${name}: maximum length is ${constraints.maxLength}.`);
+  }
+  if (constraints.pattern) {
+    const regex = new RegExp(constraints.pattern);
+    if (value && !regex.test(value)) {
+      throw new Error(`Invalid ${name}: does not match required pattern.`);
+    }
+  }
+  validateFormat(name, value, constraints.format);
+  return value;
+}
+
+function validateNumber(name: string, value: number, constraints?: NumberConstraints): number {
+  if (!constraints) return value;
+  if (constraints.minValue !== undefined && value < constraints.minValue) {
+    throw new Error(`Invalid ${name}: minimum value is ${constraints.minValue}.`);
+  }
+  if (constraints.maxValue !== undefined && value > constraints.maxValue) {
+    throw new Error(`Invalid ${name}: maximum value is ${constraints.maxValue}.`);
+  }
+  return value;
+}
+
+function validateStringCollection(name: string, values: string[], constraints?: StringConstraints): string[] {
+  if (!constraints) return values;
+  return values.map((value) => validateString(name, value, constraints));
+}
+
+function validateNumberCollection(name: string, values: number[], constraints?: NumberConstraints): number[] {
+  if (!constraints) return values;
+  return values.map((value) => validateNumber(name, value, constraints));
+}
+
+export {
+  validateString,
+  validateNumber,
+  validateStringCollection,
+  validateNumberCollection
+};

package/dist/init/templates/ts/src/datasource/csvItemSource.ts.ejs

@@ -6,7 +6,7 @@ import { parse } from "csv-parse";
 
 import type { <%= itemTypeName %> } from "../<%= schemaFolderName %>/model.js";
 import type { ItemSource } from "./itemSource.js";
-import { fromCsvRow } from "../<%= schemaFolderName %>/fromCsvRow.js";
+import { fromRow } from "../<%= schemaFolderName %>/fromRow.js";
 
 /**
  * CSV-based datasource (default). Replace with your own ItemSource as needed.
@@ -27,7 +27,7 @@ export class CsvItemSource implements ItemSource {
     const stream = createReadStream(this.filePath, { encoding: "utf8" }).pipe(parser);
 
     for await (const row of stream as AsyncIterable<Record<string, unknown>>) {
-      yield fromCsvRow(row);
+      yield fromRow(row);
     }
   }
 }

package/dist/init/templates/ts/src/datasource/itemSource.ts.ejs

@@ -5,7 +5,7 @@ import type { <%= itemTypeName %> } from "../<%= schemaFolderName %>/model.js";
 
 /**
  * Contract for any datasource that yields items for ingestion.
- * Implement this interface to swap CSV for an API, database, or other system.
+ * Implement this interface to swap the default datasource for an API, database, or other system.
  */
 export interface ItemSource {
   /**

package/dist/init/templates/ts/src/generated/csv.ts.ejs

@@ -1,54 +1 @@
-/**
- * CSV parsing helpers used by generated transforms.
- */
-/** Parse any CSV cell value into a string (empty when nullish). */
-function parseString(value: unknown): string {
-  if (value === undefined || value === null) return "";
-  return String(value);
-}
 
-/** Parse a numeric CSV cell into a number (defaults to 0). */
-function parseNumber(value: unknown): number {
-  const text = parseString(value).trim();
-  if (!text) return 0;
-  const numberValue = Number(text);
-  return Number.isFinite(numberValue) ? numberValue : 0;
-}
-
-/** Parse a boolean-ish CSV cell into a boolean. */
-function parseBoolean(value: unknown): boolean {
-  const text = parseString(value).trim().toLowerCase();
-  return text === "true" || text === "1" || text === "yes";
-}
-
-/** Split a delimited CSV cell into an array of strings. */
-function splitCollection(value: unknown): string[] {
-  const text = parseString(value).trim();
-  if (!text) return [];
-  return text.split(/\s*;\s*/).map((s) => s.trim()).filter(Boolean);
-}
-
-/** Parse a string collection from a CSV cell. */
-function parseStringCollection(value: unknown): string[] {
-  return splitCollection(value);
-}
-
-/** Parse a number collection from a CSV cell. */
-function parseNumberCollection(value: unknown): number[] {
-  return splitCollection(value).map((s) => parseNumber(s));
-}
-
-/** Read a value from a row using the first matching header. */
-function readSourceValue(row: Record<string, unknown>, headers: string[]): unknown {
-  if (headers.length === 0) return "";
-  return row[headers[0]];
-}
-
-export {
-  parseString,
-  parseNumber,
-  parseBoolean,
-  parseStringCollection,
-  parseNumberCollection,
-  readSourceValue
-};

package/dist/init/templates/ts/src/generated/fromCsvRow.ts.ejs

@@ -1,20 +1 @@
-/**
- * Map raw CSV rows into the schema model.
- */
-import type { <%= itemTypeName %> } from "./model.js";
-import { PropertyTransform } from "./propertyTransform.js";
-import { parseString, readSourceValue } from "../datasource/csv.js";
 
-const transforms = new PropertyTransform();
-
-/**
- * Convert a CSV row into the schema model using generated transforms.
- */
-export function fromCsvRow(row: Record<string, unknown>): <%= itemTypeName %> {
-  return {
-    __cocoId: <%- idRawExpression %>,
-<% for (const prop of properties) { -%>
-    <%= prop.name %>: transforms.transformProperty<%= prop.tsType ? `<${prop.tsType}>` : "" %>(<%= JSON.stringify(prop.name) %>, row),
-<% } -%>
-  };
-}

package/dist/init/templates/ts/src/generated/fromRow.ts.ejs

@@ -0,0 +1,20 @@
+/**
+ * Map raw source rows into the schema model.
+ */
+import type { <%= itemTypeName %> } from "./model.js";
+import { PropertyTransform } from "./propertyTransform.js";
+import { parseString, readSourceValue } from "../datasource/row.js";
+
+const transforms = new PropertyTransform();
+
+/**
+ * Convert a source row into the schema model using generated transforms.
+ */
+export function fromRow(row: Record<string, unknown>): <%= itemTypeName %> {
+  return {
+    internalId: <%- idRawExpression %>,
+<% for (const prop of properties) { -%>
+    <%= prop.name %>: transforms.transformProperty<%= prop.tsType ? `<${prop.tsType}>` : "" %>(<%= JSON.stringify(prop.name) %>, row),
+<% } -%>
+  };
+}

package/dist/init/templates/ts/src/generated/index.ts.ejs

@@ -4,5 +4,5 @@
 export * from "./constants.js";
 export * from "./model.js";
 export * from "./schemaPayload.js";
-export * from "./fromCsvRow.js";
+export * from "./fromRow.js";
 export * from "./itemPayload.js";