@wictorwilen/cocogen 1.0.0 → 1.0.11

package/dist/init/init.js

@@ -1,5 +1,7 @@
+import { readFileSync } from "node:fs";
 import { access, copyFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { loadIrFromTypeSpec } from "../tsp/loader.js";
 import { validateIr } from "../validate/validator.js";
 import { renderTemplate } from "./template.js";
@@ -59,10 +61,26 @@ function toCsIdentifier(name) {
     return pascal || "Item";
 }
 function toTsIdentifier(name) {
-    const cleaned = name.replaceAll(/[^A-Za-z0-9_]/g, "_");
+    const parts = name.split(/[^A-Za-z0-9]+/g).filter(Boolean);
+    if (parts.length === 0)
+        return "Item";
+    const pascal = parts.map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join("");
+    const sanitized = pascal.replaceAll(/[^A-Za-z0-9_]/g, "_");
+    return /^[A-Za-z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+}
+function toSchemaFolderName(connectionName) {
+    const cleaned = (connectionName ?? "").trim();
+    if (!cleaned)
+        return "Schema";
+    const candidate = toCsIdentifier(cleaned);
+    return candidate || "Schema";
+}
+function toTsSchemaFolderName(connectionName) {
+    const cleaned = (connectionName ?? "").trim();
     if (!cleaned)
-        return "item";
-    return /^[A-Za-z_]/.test(cleaned) ? cleaned : `_${cleaned}`;
+        return "schema";
+    const candidate = toTsIdentifier(cleaned);
+    return candidate || "schema";
 }
 function toCsNamespace(projectName) {
     const cleaned = projectName
@@ -85,7 +103,10 @@ function graphBaseUrl(ir) {
 }
 function schemaPayload(ir) {
     return {
-        properties: ir.properties.map((p) => ({
+        baseType: "microsoft.graph.externalItem",
+        properties: ir.properties
+            .filter((p) => p.name !== ir.item.contentPropertyName)
+            .map((p) => ({
             name: p.name,
             type: p.type,
             labels: p.labels.length > 0 ? p.labels : undefined,
@@ -99,11 +120,43 @@ function schemaPayload(ir) {
         })),
     };
 }
+function getGeneratorVersion() {
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(dir, "..", "package.json"),
+            path.resolve(dir, "..", "..", "package.json"),
+            path.resolve(dir, "..", "..", "..", "package.json"),
+            path.resolve(process.cwd(), "package.json"),
+        ];
+        for (const pkgPath of candidates) {
+            try {
+                const raw = readFileSync(pkgPath, "utf8");
+                const parsed = JSON.parse(raw);
+                const name = parsed.name?.trim();
+                if (name && name !== "@wictorwilen/cocogen" && name !== "cocogen") {
+                    continue;
+                }
+                if (parsed.version && parsed.version.trim().length > 0) {
+                    return parsed.version.trim();
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        // Ignore version lookup errors.
+    }
+    return "0.0.0";
+}
 function projectConfigContents(outDir, tspPath, lang) {
     const rel = path.relative(outDir, path.resolve(tspPath)).replaceAll(path.sep, "/");
     const config = {
         lang,
         tsp: rel || "./schema.tsp",
+        cocogenVersion: getGeneratorVersion(),
     };
     return JSON.stringify(config, null, 2) + "\n";
 }
@@ -127,15 +180,22 @@ async function loadProjectConfig(outDir) {
     if ((parsed.lang !== "ts" && parsed.lang !== "dotnet") || typeof parsed.tsp !== "string") {
         throw new Error(`Invalid ${COCOGEN_CONFIG_FILE}. Re-run cocogen init or fix the file.`);
     }
-    return { config: { lang: parsed.lang, tsp: parsed.tsp } };
+    return {
+        config: {
+            lang: parsed.lang,
+            tsp: parsed.tsp,
+            ...(parsed.cocogenVersion ? { cocogenVersion: parsed.cocogenVersion } : {}),
+        },
+    };
 }
-async function writeGeneratedTs(outDir, ir) {
-    await mkdir(path.join(outDir, "src", "schema"), { recursive: true });
+async function writeGeneratedTs(outDir, ir, schemaFolderName) {
+    await mkdir(path.join(outDir, "src", schemaFolderName), { recursive: true });
+    await mkdir(path.join(outDir, "src", "core"), { recursive: true });
     const modelProperties = ir.properties.map((p) => ({
         name: p.name,
         tsType: toTsType(p.type),
     }));
-    const fromCsvProperties = ir.properties.map((p) => {
+    const transformProperties = ir.properties.map((p) => {
         const parser = (() => {
             switch (p.type) {
                 case "stringCollection":
@@ -168,40 +228,33 @@ async function writeGeneratedTs(outDir, ir) {
                     source: field.source,
                 }))))
             : null;
+        const isPeopleLabel = p.labels.some((label) => label.startsWith("person"));
+        const needsManualEntity = isPeopleLabel && !p.personEntity;
+        const noSource = Boolean(p.source.noSource);
+        const expression = needsManualEntity
+            ? `(() => { throw new Error("Missing @coco.source(..., to) mappings for people entity '${p.name}'. Implement transform in propertyTransform.ts."); })()`
+            : personEntity
+                ? personEntity
+                : noSource
+                    ? `undefined as unknown as ${toTsType(p.type)}`
+                    : `${parser}(readSourceValue(row, ${JSON.stringify(p.source.csvHeaders)}))`;
         return {
             name: p.name,
-            csvHeaders: p.source.csvHeaders,
             parser,
-            expression: personEntity,
+            expression,
             isCollection: p.type === "stringCollection",
-            isExplicitSource: p.source.explicit ?? false,
             transformName: toTsIdentifier(p.name),
             tsType: toTsType(p.type),
         };
     });
-    const personEntityDefaults = ir.properties
-        .filter((p) => p.personEntity)
-        .map((p) => ({
-        name: p.name,
-        isCollection: p.type === "stringCollection",
-        expression: p.type === "stringCollection"
-            ? buildTsPersonEntityCollectionExpression((p.personEntity?.fields ?? []).map((field) => ({
-                path: field.path,
-                source: field.source,
-            })))
-            : buildTsPersonEntityExpression((p.personEntity?.fields ?? []).map((field) => ({
-                path: field.path,
-                source: field.source,
-            }))),
-    }));
-    const propertyTransforms = fromCsvProperties.filter((p) => !p.expression);
-    await writeFile(path.join(outDir, "src", "schema", "model.ts"), await renderTemplate("ts/src/generated/model.ts.ejs", {
+    await writeFile(path.join(outDir, "src", schemaFolderName, "model.ts"), await renderTemplate("ts/src/generated/model.ts.ejs", {
         itemTypeName: ir.item.typeName,
         properties: modelProperties,
     }), "utf8");
-    await writeFile(path.join(outDir, "src", "schema", "constants.ts"), await renderTemplate("ts/src/generated/constants.ts.ejs", {
+    await writeFile(path.join(outDir, "src", schemaFolderName, "constants.ts"), await renderTemplate("ts/src/generated/constants.ts.ejs", {
         graphApiVersion: ir.connection.graphApiVersion,
         contentCategory: ir.connection.contentCategory ?? null,
+        connectionName: ir.connection.connectionName ?? null,
         connectionId: ir.connection.connectionId ?? null,
         connectionDescription: ir.connection.connectionDescription ?? null,
         profileSourceWebUrl: ir.connection.profileSource?.webUrl ?? null,
@@ -211,35 +264,26 @@ async function writeGeneratedTs(outDir, ir) {
         idPropertyName: ir.item.idPropertyName,
         contentPropertyName: ir.item.contentPropertyName ?? null,
     }), "utf8");
-    await writeFile(path.join(outDir, "src", "schema", "schemaPayload.ts"), await renderTemplate("ts/src/generated/schemaPayload.ts.ejs", {
+    await writeFile(path.join(outDir, "src", schemaFolderName, "schemaPayload.ts"), await renderTemplate("ts/src/generated/schemaPayload.ts.ejs", {
         schemaPayloadJson: JSON.stringify(schemaPayload(ir), null, 2),
     }), "utf8");
     await writeFile(path.join(outDir, "src", "datasource", "csv.ts"), await renderTemplate("ts/src/generated/csv.ts.ejs", {}), "utf8");
-    if (propertyTransforms.length > 0) {
-        await writeFile(path.join(outDir, "src", "schema", "propertyTransforms.ts"), await renderTemplate("ts/src/generated/propertyTransforms.ts.ejs", {
-            properties: propertyTransforms,
-        }), "utf8");
-    }
-    await writeFile(path.join(outDir, "src", "schema", "fromCsvRow.ts"), await renderTemplate("ts/src/generated/fromCsvRow.ts.ejs", {
-        properties: fromCsvProperties,
-        hasPersonEntities: personEntityDefaults.length > 0,
-        propertyTransforms,
+    await writeFile(path.join(outDir, "src", schemaFolderName, "propertyTransformBase.ts"), await renderTemplate("ts/src/generated/propertyTransformBase.ts.ejs", {
+        properties: transformProperties,
     }), "utf8");
-    if (ir.connection.contentCategory === "people" && personEntityDefaults.length > 0) {
-        await writeFile(path.join(outDir, "src", "schema", "personEntityDefaults.ts"), await renderTemplate("ts/src/generated/personEntityDefaults.ts.ejs", {
-            defaults: personEntityDefaults,
-        }), "utf8");
-        const overridesPath = path.join(outDir, "src", "schema", "personEntityOverrides.ts");
-        try {
-            await access(overridesPath);
-        }
-        catch {
-            await writeFile(overridesPath, await renderTemplate("ts/src/personEntityOverrides.ts.ejs", {
-                names: personEntityDefaults.map((p) => p.name),
-            }), "utf8");
-        }
+    const transformOverridesPath = path.join(outDir, "src", schemaFolderName, "propertyTransform.ts");
+    try {
+        await access(transformOverridesPath);
+    }
+    catch {
+        await writeFile(transformOverridesPath, await renderTemplate("ts/src/propertyTransform.ts.ejs", {}), "utf8");
     }
+    await writeFile(path.join(outDir, "src", schemaFolderName, "fromCsvRow.ts"), await renderTemplate("ts/src/generated/fromCsvRow.ts.ejs", {
+        properties: transformProperties,
+        itemTypeName: ir.item.typeName,
+    }), "utf8");
     const propertiesObjectLines = ir.properties
+        .filter((p) => p.name !== ir.item.contentPropertyName)
         .flatMap((p) => {
         const lines = [];
         const odataType = toOdataCollectionType(p.type);
@@ -253,11 +297,16 @@ async function writeGeneratedTs(outDir, ir) {
     const contentBlock = ir.item.contentPropertyName
         ? `,\n    content: {\n      type: \"text\",\n      value: String((item as any)[contentPropertyName ?? \"\"] ?? \"\"),\n    }`
         : "";
-    await writeFile(path.join(outDir, "src", "schema", "itemPayload.ts"), await renderTemplate("ts/src/generated/itemPayload.ts.ejs", {
+    await writeFile(path.join(outDir, "src", schemaFolderName, "itemPayload.ts"), await renderTemplate("ts/src/generated/itemPayload.ts.ejs", {
         propertiesObjectLines,
         contentBlock,
+        itemTypeName: ir.item.typeName,
+    }), "utf8");
+    await writeFile(path.join(outDir, "src", schemaFolderName, "index.ts"), await renderTemplate("ts/src/generated/index.ts.ejs", {}), "utf8");
+    await writeFile(path.join(outDir, "src", "core", "connectorCore.ts"), await renderTemplate("ts/src/core/connectorCore.ts.ejs", {
+        itemTypeName: ir.item.typeName,
+        isPeopleConnector: ir.connection.contentCategory === "people",
     }), "utf8");
-    await writeFile(path.join(outDir, "src", "schema", "index.ts"), await renderTemplate("ts/src/generated/index.ts.ejs", {}), "utf8");
 }
 function toGraphPropertyTypeEnumName(type) {
     switch (type) {
@@ -361,20 +410,48 @@ function buildObjectTree(fields) {
 }
 function buildTsPersonEntityExpression(fields) {
     const tree = buildObjectTree(fields);
-    const renderNode = (node) => {
+    const indentUnit = "  ";
+    const renderNode = (node, level) => {
+        const indent = indentUnit.repeat(level);
+        const childIndent = indentUnit.repeat(level + 1);
         const entries = Object.entries(node).map(([key, value]) => {
             if (typeof value === "object" && value && "path" in value) {
                 const field = value;
                 const headers = JSON.stringify(field.source.csvHeaders);
-                return `${JSON.stringify(key)}: parseString(readSourceValue(row, ${headers}))`;
+                return `${childIndent}${JSON.stringify(key)}: parseString(readSourceValue(row, ${headers}))`;
             }
-            return `${JSON.stringify(key)}: ${renderNode(value)}`;
+            return `${childIndent}${JSON.stringify(key)}: ${renderNode(value, level + 1)}`;
         });
-        return `{ ${entries.join(", ")} }`;
+        return `{
+${entries.join(",\n")}
+${indent}}`;
     };
-    return `JSON.stringify(${renderNode(tree)})`;
+    const rendered = renderNode(tree, 2);
+    return `JSON.stringify(\n${indentUnit.repeat(2)}${rendered}\n${indentUnit.repeat(2)})`;
 }
 function buildTsPersonEntityCollectionExpression(fields) {
+    const indentUnit = "  ";
+    const renderNode = (node, level, valueVar) => {
+        const indent = indentUnit.repeat(level);
+        const childIndent = indentUnit.repeat(level + 1);
+        const entries = Object.entries(node).map(([key, value]) => {
+            if (typeof value === "object" && value && "path" in value) {
+                return `${childIndent}${JSON.stringify(key)}: ${valueVar}`;
+            }
+            return `${childIndent}${JSON.stringify(key)}: ${renderNode(value, level + 1, valueVar)}`;
+        });
+        return `{
+${entries.join(",\n")}
+${indent}}`;
+    };
+    if (fields.length === 1) {
+        const tree = buildObjectTree(fields);
+        const field = fields[0];
+        const headers = JSON.stringify(field.source.csvHeaders);
+        const rendered = renderNode(tree, 2, "value");
+        return `parseStringCollection(readSourceValue(row, ${headers}))
+  .map((value) => JSON.stringify(\n${indentUnit.repeat(2)}${rendered}\n${indentUnit.repeat(2)}))`;
+    }
     const tree = buildObjectTree(fields);
     const fieldVarByPath = new Map();
     const fieldLines = fields.map((field, index) => {
@@ -383,39 +460,66 @@ function buildTsPersonEntityCollectionExpression(fields) {
         const headers = JSON.stringify(field.source.csvHeaders);
         return `  const ${varName} = parseStringCollection(readSourceValue(row, ${headers}));`;
     });
-    const renderNode = (node) => {
+    const renderNodeMany = (node) => {
         const entries = Object.entries(node).map(([key, value]) => {
             if (typeof value === "object" && value && "path" in value) {
                 const field = value;
                 const varName = fieldVarByPath.get(field.path) ?? "";
-                return `${JSON.stringify(key)}: getValue(${varName}, index)`;
+                return `${indentUnit.repeat(2)}${JSON.stringify(key)}: getValue(${varName}, index)`;
             }
-            return `${JSON.stringify(key)}: ${renderNode(value)}`;
+            return `${indentUnit.repeat(2)}${JSON.stringify(key)}: ${renderNodeMany(value)}`;
         });
-        return `{ ${entries.join(", ")} }`;
+        return `{
+${entries.join(",\n")}
+${indentUnit}}`;
     };
     const fieldVars = [...fieldVarByPath.values()].join(", ");
     const lengthVars = fieldVars
         ? `const lengths = [${fieldVars}].map((value) => value.length);`
         : "const lengths = [0];";
-    return `(() => {\n${fieldLines.join("\n")}\n${lengthVars}\n  const maxLen = Math.max(0, ...lengths);\n  const getValue = (values: string[], index: number): string => {\n    if (values.length === 0) return \"\";\n    if (values.length === 1) return values[0] ?? \"\";\n    return values[index] ?? \"\";\n  };\n  const results: string[] = [];\n  for (let index = 0; index < maxLen; index++) {\n    results.push(JSON.stringify(${renderNode(tree)}));\n  }\n  return results;\n})()`;
+    return `(() => {\n${fieldLines.join("\n")}\n${lengthVars}\n  const maxLen = Math.max(0, ...lengths);\n  const getValue = (values: string[], index: number): string => {\n    if (values.length === 0) return \"\";\n    if (values.length === 1) return values[0] ?? \"\";\n    return values[index] ?? \"\";\n  };\n  const results: string[] = [];\n  for (let index = 0; index < maxLen; index++) {\n    results.push(JSON.stringify(\n      ${renderNodeMany(tree)}\n    ));\n  }\n  return results;\n})()`;
 }
 function buildCsPersonEntityExpression(fields) {
     const tree = buildObjectTree(fields);
-    const renderNode = (node) => {
+    const indentUnit = "    ";
+    const renderNode = (node, level) => {
+        const indent = indentUnit.repeat(level);
+        const childIndent = indentUnit.repeat(level + 1);
         const entries = Object.entries(node).map(([key, value]) => {
             if (typeof value === "object" && value && "path" in value) {
                 const field = value;
                 const headers = `new[] { ${field.source.csvHeaders.map((h) => JSON.stringify(h)).join(", ")} }`;
-                return `[${JSON.stringify(key)}] = ParseString(row, ${headers})`;
+                return `${childIndent}[${JSON.stringify(key)}] = CsvParser.ParseString(row, ${headers})`;
             }
-            return `[${JSON.stringify(key)}] = ${renderNode(value)}`;
+            return `${childIndent}[${JSON.stringify(key)}] = ${renderNode(value, level + 1)}`;
         });
-        return `new Dictionary<string, object?> { ${entries.join(", ")} }`;
+        return `new Dictionary<string, object?>\n${indent}{\n${entries.join(",\n")}\n${indent}}`;
     };
-    return `JsonSerializer.Serialize(${renderNode(tree)})`;
+    const rendered = renderNode(tree, 2);
+    return `JsonSerializer.Serialize(\n${indentUnit.repeat(2)}${rendered}\n${indentUnit.repeat(2)})`;
 }
 function buildCsPersonEntityCollectionExpression(fields) {
+    const indentUnit = "    ";
+    const renderNode = (node, level, valueVar) => {
+        const indent = indentUnit.repeat(level);
+        const childIndent = indentUnit.repeat(level + 1);
+        const entries = Object.entries(node).map(([key, value]) => {
+            if (typeof value === "object" && value && "path" in value) {
+                return `${childIndent}[${JSON.stringify(key)}] = ${valueVar}`;
+            }
+            return `${childIndent}[${JSON.stringify(key)}] = ${renderNode(value, level + 1, valueVar)}`;
+        });
+        return `new Dictionary<string, object?>\n${indent}{\n${entries.join(",\n")}\n${indent}}`;
+    };
+    if (fields.length === 1) {
+        const tree = buildObjectTree(fields);
+        const field = fields[0];
+        const headers = `new[] { ${field.source.csvHeaders.map((h) => JSON.stringify(h)).join(", ")} }`;
+        const rendered = renderNode(tree, 3, "value");
+        return `CsvParser.ParseStringCollection(row, ${headers})
+            .Select(value => JsonSerializer.Serialize(\n${indentUnit.repeat(3)}${rendered}\n${indentUnit.repeat(3)}))
+            .ToList()`;
+    }
     const tree = buildObjectTree(fields);
     const fieldVarByPath = new Map();
     const fieldLines = fields.map((field, index) => {
@@ -424,22 +528,22 @@ function buildCsPersonEntityCollectionExpression(fields) {
         const headers = `new[] { ${field.source.csvHeaders.map((h) => JSON.stringify(h)).join(", ")} }`;
         return `        var ${varName} = CsvParser.ParseStringCollection(row, ${headers});`;
     });
-    const renderNode = (node) => {
+    const renderNodeMany = (node) => {
         const entries = Object.entries(node).map(([key, value]) => {
             if (typeof value === "object" && value && "path" in value) {
                 const field = value;
                 const varName = fieldVarByPath.get(field.path) ?? "";
-                return `[${JSON.stringify(key)}] = GetValue(${varName}, index)`;
+                return `${indentUnit.repeat(3)}[${JSON.stringify(key)}] = GetValue(${varName}, index)`;
             }
-            return `[${JSON.stringify(key)}] = ${renderNode(value)}`;
+            return `${indentUnit.repeat(3)}[${JSON.stringify(key)}] = ${renderNodeMany(value)}`;
         });
-        return `new Dictionary<string, object?> { ${entries.join(", ")} }`;
+        return `new Dictionary<string, object?>\n${indentUnit.repeat(2)}{\n${entries.join(",\n")}\n${indentUnit.repeat(2)}}`;
     };
     const fieldVars = [...fieldVarByPath.values()];
     const lengthLines = fieldVars.length > 0
         ? `        var maxLen = new[] { ${fieldVars.map((v) => `${v}.Count`).join(", ")} }.Max();`
         : "        var maxLen = 0;";
-    return `new Func<List<string>>(() =>\n    {\n${fieldLines.join("\n")}\n        string GetValue(List<string> values, int index)\n        {\n            if (values.Count == 0) return \"\";\n            if (values.Count == 1) return values[0] ?? \"\";\n            return index < values.Count ? (values[index] ?? \"\") : \"\";\n        }\n${lengthLines}\n        var results = new List<string>();\n        for (var index = 0; index < maxLen; index++)\n        {\n            results.Add(JsonSerializer.Serialize(${renderNode(tree)}));\n        }\n        return results;\n    }).Invoke()`;
+    return `new Func<List<string>>(() =>\n    {\n${fieldLines.join("\n")}\n        string GetValue(List<string> values, int index)\n        {\n            if (values.Count == 0) return \"\";\n            if (values.Count == 1) return values[0] ?? \"\";\n            return index < values.Count ? (values[index] ?? \"\") : \"\";\n        }\n${lengthLines}\n        var results = new List<string>();\n        for (var index = 0; index < maxLen; index++)\n        {\n            results.Add(JsonSerializer.Serialize(${renderNodeMany(tree)}));\n        }\n        return results;\n    }).Invoke()`;
 }
 function csvEscape(value) {
     if (value.includes("\n") || value.includes("\r") || value.includes(",") || value.includes("\"")) {
@@ -466,7 +570,7 @@ function sampleValueForType(type) {
         case "dateTimeCollection":
             return "2024-01-01T00:00:00Z;2024-01-02T00:00:00Z";
         case "principal":
-            return '{"id":"00000000-0000-0000-0000-000000000000","type":"user"}';
+            return 'alice@contoso.com';
         case "string":
         default:
             return "sample";
@@ -542,16 +646,14 @@ function buildSampleCsv(ir) {
     const valueLine = headers.map((h) => csvEscape(valueByHeader.get(h) ?? "sample")).join(",");
     return `${headerLine}\n${valueLine}\n`;
 }
-async function writeGeneratedDotnet(outDir, ir, namespaceName) {
-    await mkdir(path.join(outDir, "Schema"), { recursive: true });
-    const properties = ir.properties.map((p) => ({
-        name: p.name,
-        csName: toCsIdentifier(p.name),
-        csType: toCsType(p.type),
-        csvHeaders: p.source.csvHeaders,
-        isExplicitSource: p.source.explicit ?? false,
-        isCollection: p.type === "stringCollection",
-        personEntity: p.personEntity
+async function writeGeneratedDotnet(outDir, ir, namespaceName, schemaFolderName, schemaNamespace) {
+    await mkdir(path.join(outDir, schemaFolderName), { recursive: true });
+    await mkdir(path.join(outDir, "Core"), { recursive: true });
+    const properties = ir.properties.map((p) => {
+        const parseFn = toCsParseFunction(p.type);
+        const csvHeadersLiteral = `new[] { ${p.source.csvHeaders.map((h) => JSON.stringify(h)).join(", ")} }`;
+        const isCollection = p.type === "stringCollection";
+        const personEntity = p.personEntity
             ? {
                 entity: p.personEntity.entity,
                 fields: p.personEntity.fields.map((field) => ({
@@ -559,16 +661,40 @@ async function writeGeneratedDotnet(outDir, ir, namespaceName) {
                     source: field.source,
                 })),
             }
-            : null,
-        parseFn: toCsParseFunction(p.type),
-        graphTypeEnumName: toGraphPropertyTypeEnumName(p.type),
-        description: p.description,
-        labels: p.labels,
-        aliases: p.aliases,
-        search: p.search,
-        type: p.type,
-    }));
+            : null;
+        const isPeopleLabel = p.labels.some((label) => label.startsWith("person"));
+        const needsManualEntity = isPeopleLabel && !p.personEntity;
+        const noSource = Boolean(p.source.noSource);
+        const transformExpression = needsManualEntity
+            ? `throw new NotImplementedException("Missing @coco.source(..., to) mappings for people entity '${p.name}'. Implement in PropertyTransform.cs.")`
+            : personEntity
+                ? isCollection
+                    ? buildCsPersonEntityCollectionExpression(personEntity.fields)
+                    : buildCsPersonEntityExpression(personEntity.fields)
+                : noSource
+                    ? "default!"
+                    : `${parseFn}(row, ${csvHeadersLiteral})`;
+        return {
+            name: p.name,
+            csName: toCsIdentifier(p.name),
+            csType: toCsType(p.type),
+            csvHeaders: p.source.csvHeaders,
+            csvHeadersLiteral,
+            isCollection,
+            personEntity,
+            parseFn,
+            transformExpression,
+            transformThrows: needsManualEntity,
+            graphTypeEnumName: toGraphPropertyTypeEnumName(p.type),
+            description: p.description,
+            labels: p.labels,
+            aliases: p.aliases,
+            search: p.search,
+            type: p.type,
+        };
+    });
     const schemaPropertyLines = properties
+        .filter((p) => p.name !== ir.item.contentPropertyName)
         .map((p) => {
         const labels = p.labels.length > 0
             ? `new List<string> { ${p.labels.map((l) => JSON.stringify(l)).join(", ")} }`
@@ -615,29 +741,11 @@ async function writeGeneratedDotnet(outDir, ir, namespaceName) {
     const constructorArgLines = properties
         .map((p, index) => {
         const comma = index < properties.length - 1 ? "," : "";
-        if (p.personEntity) {
-            const method = p.isCollection ? "TransformCollection" : "Transform";
-            const defaults = p.isCollection ? "BuildDefaultCollection" : "BuildDefault";
-            return `            PersonEntityOverrides.${method}(${JSON.stringify(p.name)}, row, PersonEntityDefaults.${defaults}(${JSON.stringify(p.name)}, row))${comma}`;
-        }
-        const headersLiteral = `new[] { ${p.csvHeaders.map((h) => JSON.stringify(h)).join(", ")} }`;
-        if (p.isExplicitSource) {
-            return `            PropertyTransforms.Transform${p.csName}(CsvParser.ReadValue(row, ${headersLiteral}))${comma}`;
-        }
-        return `            PropertyTransforms.Transform${p.csName}(row)${comma}`;
+        return `            (${p.csType})transforms.TransformProperty(${JSON.stringify(p.name)}, row)${comma}`;
     })
         .join("\n");
-    const personEntityDefaults = properties
-        .filter((p) => p.personEntity)
-        .map((p) => ({
-        name: p.name,
-        isCollection: p.isCollection,
-        expression: p.isCollection
-            ? buildCsPersonEntityCollectionExpression(p.personEntity.fields)
-            : buildCsPersonEntityExpression(p.personEntity.fields),
-    }));
-    const propertyTransforms = properties.filter((p) => !p.personEntity);
     const propertiesObjectLines = properties
+        .filter((p) => p.name !== ir.item.contentPropertyName)
         .flatMap((p) => {
         const lines = [];
         const odataType = toOdataCollectionType(p.type);
@@ -659,15 +767,16 @@ async function writeGeneratedDotnet(outDir, ir, namespaceName) {
             "        };",
         ].join("\n")
         : "";
-    await writeFile(path.join(outDir, "Schema", "Model.cs"), await renderTemplate("dotnet/Generated/Model.cs.ejs", {
-        namespaceName,
+    await writeFile(path.join(outDir, schemaFolderName, "Model.cs"), await renderTemplate("dotnet/Generated/Model.cs.ejs", {
+        schemaNamespace,
         itemTypeName: ir.item.typeName,
         properties: properties.map((p) => ({ csName: p.csName, csType: p.csType })),
     }), "utf8");
-    await writeFile(path.join(outDir, "Schema", "Constants.cs"), await renderTemplate("dotnet/Generated/Constants.cs.ejs", {
-        namespaceName,
+    await writeFile(path.join(outDir, schemaFolderName, "Constants.cs"), await renderTemplate("dotnet/Generated/Constants.cs.ejs", {
+        schemaNamespace,
         graphApiVersion: ir.connection.graphApiVersion,
         contentCategory: ir.connection.contentCategory ?? null,
+        connectionName: ir.connection.connectionName ?? null,
         profileSourceWebUrl: ir.connection.profileSource?.webUrl ?? null,
         profileSourceDisplayName: ir.connection.profileSource?.displayName ?? null,
         profileSourcePriority: ir.connection.profileSource?.priority ?? null,
@@ -675,47 +784,50 @@ async function writeGeneratedDotnet(outDir, ir, namespaceName) {
         idPropertyName: ir.item.idPropertyName,
         contentPropertyName: ir.item.contentPropertyName ?? null,
     }), "utf8");
-    await writeFile(path.join(outDir, "Schema", "SchemaPayload.cs"), await renderTemplate("dotnet/Generated/SchemaPayload.cs.ejs", {
-        namespaceName,
+    await writeFile(path.join(outDir, schemaFolderName, "SchemaPayload.cs"), await renderTemplate("dotnet/Generated/SchemaPayload.cs.ejs", {
+        schemaNamespace,
         schemaPropertyLines,
         graphApiVersion: ir.connection.graphApiVersion,
     }), "utf8");
     await writeFile(path.join(outDir, "Datasource", "CsvParser.cs"), await renderTemplate("dotnet/Generated/CsvParser.cs.ejs", {
         namespaceName,
     }), "utf8");
-    if (propertyTransforms.length > 0) {
-        await writeFile(path.join(outDir, "Schema", "PropertyTransforms.cs"), await renderTemplate("dotnet/Generated/PropertyTransforms.cs.ejs", {
-            namespaceName,
-            properties: propertyTransforms,
-        }), "utf8");
-    }
-    await writeFile(path.join(outDir, "Schema", "FromCsvRow.cs"), await renderTemplate("dotnet/Generated/FromCsvRow.cs.ejs", {
+    await writeFile(path.join(outDir, schemaFolderName, "PropertyTransformBase.cs"), await renderTemplate("dotnet/Generated/PropertyTransformBase.cs.ejs", {
         namespaceName,
-        constructorArgLines,
+        schemaNamespace,
+        properties,
+        usesPersonEntity: properties.some((p) => p.personEntity),
     }), "utf8");
-    if (ir.connection.contentCategory === "people" && personEntityDefaults.length > 0) {
-        await writeFile(path.join(outDir, "Schema", "PersonEntityDefaults.cs"), await renderTemplate("dotnet/Generated/PersonEntityDefaults.cs.ejs", {
-            namespaceName,
-            defaults: personEntityDefaults,
+    const transformOverridesPath = path.join(outDir, schemaFolderName, "PropertyTransform.cs");
+    try {
+        await access(transformOverridesPath);
+    }
+    catch {
+        await writeFile(transformOverridesPath, await renderTemplate("dotnet/PropertyTransform.cs.ejs", {
+            schemaNamespace,
         }), "utf8");
-        const overridesPath = path.join(outDir, "Schema", "PersonEntityOverrides.cs");
-        try {
-            await access(overridesPath);
-        }
-        catch {
-            await writeFile(overridesPath, await renderTemplate("dotnet/PersonEntityOverrides.cs.ejs", {
-                namespaceName,
-                names: personEntityDefaults.map((p) => p.name),
-            }), "utf8");
-        }
     }
-    await writeFile(path.join(outDir, "Schema", "ItemPayload.cs"), await renderTemplate("dotnet/Generated/ItemPayload.cs.ejs", {
+    await writeFile(path.join(outDir, schemaFolderName, "FromCsvRow.cs"), await renderTemplate("dotnet/Generated/FromCsvRow.cs.ejs", {
         namespaceName,
+        schemaNamespace,
+        itemTypeName: ir.item.typeName,
+        constructorArgLines,
+    }), "utf8");
+    await writeFile(path.join(outDir, schemaFolderName, "ItemPayload.cs"), await renderTemplate("dotnet/Generated/ItemPayload.cs.ejs", {
+        schemaNamespace,
+        itemTypeName: ir.item.typeName,
         itemIdExpression,
         propertiesObjectLines,
         contentBlock,
         graphApiVersion: ir.connection.graphApiVersion,
     }), "utf8");
+    await writeFile(path.join(outDir, "Core", "ConnectorCore.cs"), await renderTemplate("dotnet/Core/ConnectorCore.cs.ejs", {
+        namespaceName,
+        schemaNamespace,
+        itemTypeName: ir.item.typeName,
+        isPeopleConnector: ir.connection.contentCategory === "people",
+        graphApiVersion: ir.connection.graphApiVersion,
+    }), "utf8");
 }
 function formatValidationErrors(ir) {
     const issues = validateIr(ir);
@@ -741,7 +853,8 @@ export async function updateTsProject(options) {
     if (validationMessage) {
         throw new Error(`Schema validation failed:\n${validationMessage}`);
     }
-    await writeGeneratedTs(outDir, ir);
+    const schemaFolderName = toTsSchemaFolderName(ir.connection.connectionName);
+    await writeGeneratedTs(outDir, ir, schemaFolderName);
     if (options.tspPath) {
         await writeFile(path.join(outDir, COCOGEN_CONFIG_FILE), projectConfigContents(outDir, tspPath, "ts"), "utf8");
     }
@@ -763,7 +876,9 @@ export async function updateDotnetProject(options) {
         throw new Error(`Schema validation failed:\n${validationMessage}`);
     }
     const namespaceName = toCsNamespace(path.basename(outDir));
-    await writeGeneratedDotnet(outDir, ir, namespaceName);
+    const schemaFolderName = toSchemaFolderName(ir.connection.connectionName);
+    const schemaNamespace = `${namespaceName}.${schemaFolderName}`;
+    await writeGeneratedDotnet(outDir, ir, namespaceName, schemaFolderName, schemaNamespace);
     if (options.tspPath) {
         await writeFile(path.join(outDir, COCOGEN_CONFIG_FILE), projectConfigContents(outDir, tspPath, "dotnet"), "utf8");
     }
@@ -789,9 +904,10 @@ export async function initTsProject(options) {
         throw new Error(`Schema validation failed:\n${validationMessage}`);
     }
     const projectName = options.projectName ?? path.basename(outDir);
+    const schemaFolderName = toTsSchemaFolderName(ir.connection.connectionName);
     await mkdir(path.join(outDir, "src"), { recursive: true });
     await mkdir(path.join(outDir, "src", "datasource"), { recursive: true });
-    await mkdir(path.join(outDir, "src", "schema"), { recursive: true });
+    await mkdir(path.join(outDir, "src", schemaFolderName), { recursive: true });
     await writeFile(path.join(outDir, "package.json"), await renderTemplate("ts/package.json.ejs", {
         projectName,
         isPeopleConnector: ir.connection.contentCategory === "people",
@@ -801,13 +917,18 @@ export async function initTsProject(options) {
     await writeFile(path.join(outDir, ".env.example"), await renderTemplate("ts/.env.example.ejs", {
         itemTypeName: ir.item.typeName,
         isPeopleConnector: ir.connection.contentCategory === "people",
+        connectionName: ir.connection.connectionName ?? null,
         connectionId: ir.connection.connectionId ?? null,
         connectionDescription: ir.connection.connectionDescription ?? null,
         profileSourceWebUrl: ir.connection.profileSource?.webUrl ?? null,
         profileSourceDisplayName: ir.connection.profileSource?.displayName ?? null,
         profileSourcePriority: ir.connection.profileSource?.priority ?? null,
     }), "utf8");
-    await writeFile(path.join(outDir, "README.md"), await renderTemplate("ts/README.md.ejs", { isPeopleConnector: ir.connection.contentCategory === "people" }), "utf8");
+    await writeFile(path.join(outDir, "README.md"), await renderTemplate("ts/README.md.ejs", {
+        isPeopleConnector: ir.connection.contentCategory === "people",
+        itemTypeName: ir.item.typeName,
+        schemaFolderName,
+    }), "utf8");
     const copiedTspPath = path.join(outDir, "schema.tsp");
     await copyFile(path.resolve(options.tspPath), copiedTspPath);
     await writeFile(path.join(outDir, COCOGEN_CONFIG_FILE), projectConfigContents(outDir, copiedTspPath, "ts"), "utf8");
@@ -828,12 +949,20 @@ export async function initTsProject(options) {
     await writeFile(path.join(outDir, "src", "cli.ts"), await renderTemplate("ts/src/cli.ts.ejs", {
         graphBaseUrl: graphBaseUrl(ir),
         isPeopleConnector: ir.connection.contentCategory === "people",
+        itemTypeName: ir.item.typeName,
+        schemaFolderName,
+    }), "utf8");
+    await writeFile(path.join(outDir, "src", "datasource", "itemSource.ts"), await renderTemplate("ts/src/datasource/itemSource.ts.ejs", {
+        itemTypeName: ir.item.typeName,
+        schemaFolderName,
+    }), "utf8");
+    await writeFile(path.join(outDir, "src", "datasource", "csvItemSource.ts"), await renderTemplate("ts/src/datasource/csvItemSource.ts.ejs", {
+        itemTypeName: ir.item.typeName,
+        schemaFolderName,
     }), "utf8");
-    await writeFile(path.join(outDir, "src", "datasource", "itemSource.ts"), await renderTemplate("ts/src/datasource/itemSource.ts.ejs", {}), "utf8");
-    await writeFile(path.join(outDir, "src", "datasource", "csvItemSource.ts"), await renderTemplate("ts/src/datasource/csvItemSource.ts.ejs", {}), "utf8");
     await writeFile(path.join(outDir, "data.csv"), buildSampleCsv(ir), "utf8");
-    await writeGeneratedTs(outDir, ir);
-    await writeFile(path.join(outDir, "src", "index.ts"), await renderTemplate("ts/src/index.ts.ejs", {}), "utf8");
+    await writeGeneratedTs(outDir, ir, schemaFolderName);
+    await writeFile(path.join(outDir, "src", "index.ts"), await renderTemplate("ts/src/index.ts.ejs", { schemaFolderName }), "utf8");
     return { outDir, ir };
 }
 export async function initDotnetProject(options) {
@@ -849,8 +978,10 @@ export async function initDotnetProject(options) {
     }
     const projectName = options.projectName ?? path.basename(outDir);
     const namespaceName = toCsNamespace(projectName);
+    const schemaFolderName = toSchemaFolderName(ir.connection.connectionName);
+    const schemaNamespace = `${namespaceName}.${schemaFolderName}`;
     await mkdir(path.join(outDir, "Datasource"), { recursive: true });
-    await mkdir(path.join(outDir, "Schema"), { recursive: true });
+    await mkdir(path.join(outDir, schemaFolderName), { recursive: true });
     await writeFile(path.join(outDir, `${projectName}.csproj`), await renderTemplate("dotnet/project.csproj.ejs", {
         graphApiVersion: ir.connection.graphApiVersion,
     }), "utf8");
@@ -860,15 +991,26 @@ export async function initDotnetProject(options) {
     await writeFile(path.join(outDir, "tspconfig.yaml"), await renderTemplate("dotnet/tspconfig.yaml.ejs", {}), "utf8");
     await writeFile(path.join(outDir, "Program.cs"), await renderTemplate("dotnet/Program.commandline.cs.ejs", {
         namespaceName,
+        schemaNamespace,
+        itemTypeName: ir.item.typeName,
         isPeopleConnector: ir.connection.contentCategory === "people",
         graphApiVersion: ir.connection.graphApiVersion,
     }), "utf8");
-    await writeFile(path.join(outDir, "Datasource", "IItemSource.cs"), await renderTemplate("dotnet/Datasource/IItemSource.cs.ejs", { namespaceName }), "utf8");
-    await writeFile(path.join(outDir, "Datasource", "CsvItemSource.cs"), await renderTemplate("dotnet/Datasource/CsvItemSource.cs.ejs", { namespaceName }), "utf8");
+    await writeFile(path.join(outDir, "Datasource", "IItemSource.cs"), await renderTemplate("dotnet/Datasource/IItemSource.cs.ejs", {
+        namespaceName,
+        schemaNamespace,
+        itemTypeName: ir.item.typeName,
+    }), "utf8");
+    await writeFile(path.join(outDir, "Datasource", "CsvItemSource.cs"), await renderTemplate("dotnet/Datasource/CsvItemSource.cs.ejs", {
+        namespaceName,
+        schemaNamespace,
+        itemTypeName: ir.item.typeName,
+    }), "utf8");
     await writeFile(path.join(outDir, "data.csv"), buildSampleCsv(ir), "utf8");
     await writeFile(path.join(outDir, "appsettings.json"), await renderTemplate("dotnet/appsettings.json.ejs", {
         itemTypeName: ir.item.typeName,
         isPeopleConnector: ir.connection.contentCategory === "people",
+        connectionName: ir.connection.connectionName ?? null,
         connectionId: ir.connection.connectionId ?? null,
         connectionDescription: ir.connection.connectionDescription ?? null,
         profileSourceWebUrl: ir.connection.profileSource?.webUrl ?? null,
@@ -876,11 +1018,15 @@ export async function initDotnetProject(options) {
         profileSourcePriority: ir.connection.profileSource?.priority ?? null,
     }), "utf8");
     await writeFile(path.join(outDir, ".gitignore"), await renderTemplate("dotnet/.gitignore.ejs", {}), "utf8");
-    await writeFile(path.join(outDir, "README.md"), await renderTemplate("dotnet/README.md.ejs", { isPeopleConnector: ir.connection.contentCategory === "people" }), "utf8");
+    await writeFile(path.join(outDir, "README.md"), await renderTemplate("dotnet/README.md.ejs", {
+        isPeopleConnector: ir.connection.contentCategory === "people",
+        itemTypeName: ir.item.typeName,
+        schemaFolderName,
+    }), "utf8");
     const copiedTspPath = path.join(outDir, "schema.tsp");
     await copyFile(path.resolve(options.tspPath), copiedTspPath);
     await writeFile(path.join(outDir, COCOGEN_CONFIG_FILE), projectConfigContents(outDir, copiedTspPath, "dotnet"), "utf8");
-    await writeGeneratedDotnet(outDir, ir, namespaceName);
+    await writeGeneratedDotnet(outDir, ir, namespaceName, schemaFolderName, schemaNamespace);
     return { outDir, ir };
 }
 //# sourceMappingURL=init.js.map