@wictorwilen/cocogen 1.0.17 → 1.0.19

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

@@ -1,22 +1 @@
-// Map CSV rows into the schema model.
-using <%= namespaceName %>;
-using <%= namespaceName %>.Datasource;
 
-namespace <%= schemaNamespace %>;
-
-/// <summary>
-/// Maps CSV rows into the schema model using generated transforms.
-/// </summary>
-public static class FromCsvRow
-{
-    /// <summary>
-    /// Convert a CSV 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/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/ItemPayload.cs.ejs

@@ -1,9 +1,7 @@
 <% const graphNs = graphApiVersion === "beta" ? "Microsoft.Graph.Beta" : "Microsoft.Graph"; -%>
 // Build ExternalItem payloads for Graph ingestion.
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.RegularExpressions;
 using <%= graphNs %>.Models.ExternalConnectors;
+using <%= namespaceName %>.Core;
 
 namespace <%= schemaNamespace %>;
 
@@ -25,29 +23,7 @@ public static class ItemPayload
 
     private static string EncodeId(string value)
     {
-        if (string.IsNullOrEmpty(value)) return string.Empty;
-        return IdEncoding switch
-        {
-            "base64" => ToBase64Url(Encoding.UTF8.GetBytes(value)),
-            "hash" => ToBase64Url(SHA256.HashData(Encoding.UTF8.GetBytes(value))),
-            _ => Slugify(value),
-        };
-    }
-
-    private static string ToBase64Url(byte[] bytes)
-    {
-        return Convert.ToBase64String(bytes)
-            .TrimEnd('=')
-            .Replace('+', '-')
-            .Replace('/', '_');
-    }
-
-    private static string Slugify(string value)
-    {
-        var lower = value.Trim().ToLowerInvariant();
-        var slug = Regex.Replace(lower, "[^a-z0-9]+", "-");
-        slug = Regex.Replace(slug, "^-+|-+$", "");
-        return slug;
+        return ItemId.GetItemId(value, IdEncoding);
     }
 
     /// <summary>

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

@@ -1,16 +1,19 @@
 // Generated property transforms derived from TypeSpec.
 using System;
 using System.Collections.Generic;
-<% if (usesPersonEntity) { -%>
+<% if (usesPersonEntity || usesLinq) { -%>
 using System.Linq;
+<% } -%>
+<% if (usesPersonEntity) { -%>
 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 +33,17 @@ 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 %>;
-    <% } -%>
+<%_ } -%>
     }
 
 <% } -%>
+
 }

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/itemId.ts.ejs

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+
+type ItemRecord = Record<string, unknown>;
+
+export type IdEncoding = "slug" | "base64" | "hash";
+
+export function toBase64Url(value: string | Buffer): string {
+  const buffer = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+  return buffer
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/g, "");
+}
+
+export function slugify(value: string): string {
+  const normalized = value.normalize("NFKD");
+  const slug = normalized
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-+|-+$)/g, "");
+  return slug;
+}
+
+export function encodeId(value: string, encoding: IdEncoding): string {
+  if (encoding === "base64") return toBase64Url(value);
+  if (encoding === "hash") return toBase64Url(createHash("sha256").update(value, "utf8").digest());
+  return slugify(value);
+}
+
+export function getItemId(item: ItemRecord, idPropertyName: string, encoding: IdEncoding): string {
+  const raw = (item as any).internalId ?? (item as any)[idPropertyName] ?? "";
+  return encodeId(String(raw ?? ""), encoding);
+}

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 {
   /**