@wictorwilen/cocogen 1.0.0

package/dist/init/init.js

@@ -0,0 +1,886 @@
+import { access, copyFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { loadIrFromTypeSpec } from "../tsp/loader.js";
+import { validateIr } from "../validate/validator.js";
+import { renderTemplate } from "./template.js";
+const COCOGEN_CONFIG_FILE = "cocogen.json";
+function toTsType(type) {
+    switch (type) {
+        case "string":
+            return "string";
+        case "boolean":
+            return "boolean";
+        case "int64":
+        case "double":
+            return "number";
+        case "dateTime":
+            return "string";
+        case "stringCollection":
+            return "string[]";
+        case "int64Collection":
+        case "doubleCollection":
+            return "number[]";
+        case "dateTimeCollection":
+            return "string[]";
+        case "principal":
+            return "string";
+        default:
+            return "unknown";
+    }
+}
+function toCsType(type) {
+    switch (type) {
+        case "string":
+        case "principal":
+            return "string";
+        case "boolean":
+            return "bool";
+        case "int64":
+            return "long";
+        case "double":
+            return "double";
+        case "dateTime":
+            return "DateTimeOffset";
+        case "stringCollection":
+            return "List<string>";
+        case "int64Collection":
+            return "List<long>";
+        case "doubleCollection":
+            return "List<double>";
+        case "dateTimeCollection":
+            return "List<DateTimeOffset>";
+        default:
+            return "object";
+    }
+}
+function toCsIdentifier(name) {
+    const parts = name.split(/[_\-\s]+/g).filter(Boolean);
+    const pascal = parts.map((p) => p.slice(0, 1).toUpperCase() + p.slice(1)).join("");
+    return pascal || "Item";
+}
+function toTsIdentifier(name) {
+    const cleaned = name.replaceAll(/[^A-Za-z0-9_]/g, "_");
+    if (!cleaned)
+        return "item";
+    return /^[A-Za-z_]/.test(cleaned) ? cleaned : `_${cleaned}`;
+}
+function toCsNamespace(projectName) {
+    const cleaned = projectName
+        .replaceAll(/[^A-Za-z0-9_\.\-\s]/g, "")
+        .replaceAll(/[\-\s]+/g, "_")
+        .replaceAll(/\.+/g, ".")
+        .trim();
+    const parts = cleaned.split(".").filter(Boolean).map(toCsIdentifier);
+    return parts.length > 0 ? parts.join(".") : "Connector";
+}
+async function ensureEmptyDir(outDir, force) {
+    await mkdir(outDir, { recursive: true });
+    const entries = await readdir(outDir);
+    if (entries.length > 0 && !force) {
+        throw new Error(`Output directory is not empty: ${outDir}. Use an empty folder or pass --force to overwrite.`);
+    }
+}
+function graphBaseUrl(ir) {
+    return `https://graph.microsoft.com/${ir.connection.graphApiVersion}`;
+}
+function schemaPayload(ir) {
+    return {
+        properties: ir.properties.map((p) => ({
+            name: p.name,
+            type: p.type,
+            labels: p.labels.length > 0 ? p.labels : undefined,
+            aliases: p.aliases.length > 0 ? p.aliases : undefined,
+            description: p.description,
+            isSearchable: p.search.searchable ?? undefined,
+            isQueryable: p.search.queryable ?? undefined,
+            isRetrievable: p.search.retrievable ?? undefined,
+            isRefinable: p.search.refinable ?? undefined,
+            isExactMatchRequired: p.search.exactMatchRequired ?? undefined,
+        })),
+    };
+}
+function projectConfigContents(outDir, tspPath, lang) {
+    const rel = path.relative(outDir, path.resolve(tspPath)).replaceAll(path.sep, "/");
+    const config = {
+        lang,
+        tsp: rel || "./schema.tsp",
+    };
+    return JSON.stringify(config, null, 2) + "\n";
+}
+async function loadProjectConfig(outDir) {
+    const tryRead = async (fileName) => {
+        try {
+            return await readFile(path.join(outDir, fileName), "utf8");
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    };
+    const raw = await tryRead(COCOGEN_CONFIG_FILE);
+    if (!raw) {
+        throw new Error(`Missing ${COCOGEN_CONFIG_FILE}. Re-run cocogen init or fix the file.`);
+    }
+    const parsed = JSON.parse(raw);
+    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 } };
+}
+async function writeGeneratedTs(outDir, ir) {
+    await mkdir(path.join(outDir, "src", "schema"), { recursive: true });
+    const modelProperties = ir.properties.map((p) => ({
+        name: p.name,
+        tsType: toTsType(p.type),
+    }));
+    const fromCsvProperties = ir.properties.map((p) => {
+        const parser = (() => {
+            switch (p.type) {
+                case "stringCollection":
+                    return "parseStringCollection";
+                case "int64Collection":
+                case "doubleCollection":
+                    return "parseNumberCollection";
+                case "dateTimeCollection":
+                    return "parseStringCollection";
+                case "boolean":
+                    return "parseBoolean";
+                case "int64":
+                case "double":
+                    return "parseNumber";
+                case "principal":
+                case "dateTime":
+                case "string":
+                default:
+                    return "parseString";
+            }
+        })();
+        const personEntity = p.personEntity
+            ? (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,
+                }))))
+            : null;
+        return {
+            name: p.name,
+            csvHeaders: p.source.csvHeaders,
+            parser,
+            expression: personEntity,
+            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", {
+        itemTypeName: ir.item.typeName,
+        properties: modelProperties,
+    }), "utf8");
+    await writeFile(path.join(outDir, "src", "schema", "constants.ts"), await renderTemplate("ts/src/generated/constants.ts.ejs", {
+        graphApiVersion: ir.connection.graphApiVersion,
+        contentCategory: ir.connection.contentCategory ?? 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,
+        itemTypeName: ir.item.typeName,
+        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", {
+        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,
+    }), "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 propertiesObjectLines = ir.properties
+        .flatMap((p) => {
+        const lines = [];
+        const odataType = toOdataCollectionType(p.type);
+        if (odataType) {
+            lines.push(`      ${JSON.stringify(`${p.name}@odata.type`)}: ${JSON.stringify(odataType)},`);
+        }
+        lines.push(`      ${JSON.stringify(p.name)}: item.${p.name},`);
+        return lines;
+    })
+        .join("\n");
+    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", {
+        propertiesObjectLines,
+        contentBlock,
+    }), "utf8");
+    await writeFile(path.join(outDir, "src", "schema", "index.ts"), await renderTemplate("ts/src/generated/index.ts.ejs", {}), "utf8");
+}
+function toGraphPropertyTypeEnumName(type) {
+    switch (type) {
+        case "string":
+            return "String";
+        case "boolean":
+            return "Boolean";
+        case "int64":
+            return "Int64";
+        case "double":
+            return "Double";
+        case "dateTime":
+            return "DateTime";
+        case "stringCollection":
+            return "StringCollection";
+        case "int64Collection":
+            return "Int64Collection";
+        case "doubleCollection":
+            return "DoubleCollection";
+        case "dateTimeCollection":
+            return "DateTimeCollection";
+        case "principal":
+            return "Principal";
+        default:
+            return "String";
+    }
+}
+function toOdataCollectionType(type) {
+    switch (type) {
+        case "stringCollection":
+            return "Collection(String)";
+        case "int64Collection":
+            return "Collection(Int64)";
+        case "doubleCollection":
+            return "Collection(Double)";
+        case "dateTimeCollection":
+            return "Collection(DateTimeOffset)";
+        default:
+            return null;
+    }
+}
+function toCsParseFunction(type) {
+    switch (type) {
+        case "stringCollection":
+            return "CsvParser.ParseStringCollection";
+        case "int64Collection":
+            return "CsvParser.ParseInt64Collection";
+        case "doubleCollection":
+            return "CsvParser.ParseDoubleCollection";
+        case "dateTimeCollection":
+            return "CsvParser.ParseDateTimeCollection";
+        case "boolean":
+            return "CsvParser.ParseBoolean";
+        case "int64":
+            return "CsvParser.ParseInt64";
+        case "double":
+            return "CsvParser.ParseDouble";
+        case "dateTime":
+            return "CsvParser.ParseDateTime";
+        case "principal":
+        case "string":
+        default:
+            return "CsvParser.ParseString";
+    }
+}
+function toCsPropertyValueExpression(type, csPropertyName) {
+    switch (type) {
+        case "dateTime":
+            return `item.${csPropertyName}.ToString("o")`;
+        case "dateTimeCollection":
+            return `item.${csPropertyName}.Select((x) => x.ToString("o")).ToList()`;
+        default:
+            return `item.${csPropertyName}`;
+    }
+}
+function buildObjectTree(fields) {
+    const root = {};
+    for (const field of fields) {
+        const parts = field.path.split(".").map((p) => p.trim()).filter(Boolean);
+        if (parts.length === 0)
+            continue;
+        let cursor = root;
+        for (let i = 0; i < parts.length; i++) {
+            const key = parts[i];
+            if (i === parts.length - 1) {
+                cursor[key] = field;
+                continue;
+            }
+            const next = cursor[key];
+            if (typeof next === "object" && next && !Array.isArray(next) && !("path" in next)) {
+                cursor = next;
+            }
+            else {
+                const child = {};
+                cursor[key] = child;
+                cursor = child;
+            }
+        }
+    }
+    return root;
+}
+function buildTsPersonEntityExpression(fields) {
+    const tree = buildObjectTree(fields);
+    const renderNode = (node) => {
+        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 `${JSON.stringify(key)}: ${renderNode(value)}`;
+        });
+        return `{ ${entries.join(", ")} }`;
+    };
+    return `JSON.stringify(${renderNode(tree)})`;
+}
+function buildTsPersonEntityCollectionExpression(fields) {
+    const tree = buildObjectTree(fields);
+    const fieldVarByPath = new Map();
+    const fieldLines = fields.map((field, index) => {
+        const varName = `field${index}`;
+        fieldVarByPath.set(field.path, varName);
+        const headers = JSON.stringify(field.source.csvHeaders);
+        return `  const ${varName} = parseStringCollection(readSourceValue(row, ${headers}));`;
+    });
+    const renderNode = (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 `${JSON.stringify(key)}: ${renderNode(value)}`;
+        });
+        return `{ ${entries.join(", ")} }`;
+    };
+    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})()`;
+}
+function buildCsPersonEntityExpression(fields) {
+    const tree = buildObjectTree(fields);
+    const renderNode = (node) => {
+        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 `[${JSON.stringify(key)}] = ${renderNode(value)}`;
+        });
+        return `new Dictionary<string, object?> { ${entries.join(", ")} }`;
+    };
+    return `JsonSerializer.Serialize(${renderNode(tree)})`;
+}
+function buildCsPersonEntityCollectionExpression(fields) {
+    const tree = buildObjectTree(fields);
+    const fieldVarByPath = new Map();
+    const fieldLines = fields.map((field, index) => {
+        const varName = `field${index}`;
+        fieldVarByPath.set(field.path, varName);
+        const headers = `new[] { ${field.source.csvHeaders.map((h) => JSON.stringify(h)).join(", ")} }`;
+        return `        var ${varName} = CsvParser.ParseStringCollection(row, ${headers});`;
+    });
+    const renderNode = (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 `[${JSON.stringify(key)}] = ${renderNode(value)}`;
+        });
+        return `new Dictionary<string, object?> { ${entries.join(", ")} }`;
+    };
+    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()`;
+}
+function csvEscape(value) {
+    if (value.includes("\n") || value.includes("\r") || value.includes(",") || value.includes("\"")) {
+        return `"${value.replaceAll("\"", '""')}"`;
+    }
+    return value;
+}
+function sampleValueForType(type) {
+    switch (type) {
+        case "boolean":
+            return "true";
+        case "int64":
+            return "123";
+        case "double":
+            return "1.23";
+        case "dateTime":
+            return "2024-01-01T00:00:00Z";
+        case "stringCollection":
+            return "alpha;beta";
+        case "int64Collection":
+            return "1;2";
+        case "doubleCollection":
+            return "1.1;2.2";
+        case "dateTimeCollection":
+            return "2024-01-01T00:00:00Z;2024-01-02T00:00:00Z";
+        case "principal":
+            return '{"id":"00000000-0000-0000-0000-000000000000","type":"user"}';
+        case "string":
+        default:
+            return "sample";
+    }
+}
+function sampleValueForHeader(header, type) {
+    const lower = header.toLowerCase();
+    if (lower.includes("job title"))
+        return "Software Engineer";
+    if (lower.includes("company"))
+        return "Contoso";
+    if (lower.includes("employee"))
+        return "E123";
+    if (lower.includes("upn") || lower.includes("userprincipal"))
+        return "user@contoso.com";
+    if (lower.includes("email"))
+        return "user@contoso.com";
+    if (lower.includes("phone"))
+        return "+1 555 0100";
+    if (lower.includes("name"))
+        return "Ada Lovelace";
+    if (lower.includes("skill"))
+        return "TypeScript;Python";
+    if (lower.includes("proficiency"))
+        return "advancedProfessional;expert";
+    if (lower.includes("address"))
+        return "1 Main St";
+    if (lower.includes("city"))
+        return "Seattle";
+    if (lower.includes("country"))
+        return "US";
+    if (lower.includes("note") || lower.includes("bio"))
+        return "Sample profile note";
+    return type ? sampleValueForType(type) : "sample";
+}
+function buildSampleCsv(ir) {
+    const headers = [];
+    const seen = new Set();
+    const addHeader = (header) => {
+        if (seen.has(header))
+            return;
+        seen.add(header);
+        headers.push(header);
+    };
+    for (const prop of ir.properties) {
+        if (prop.personEntity) {
+            for (const field of prop.personEntity.fields) {
+                for (const header of field.source.csvHeaders)
+                    addHeader(header);
+            }
+            continue;
+        }
+        for (const header of prop.source.csvHeaders)
+            addHeader(header);
+    }
+    const valueByHeader = new Map();
+    for (const prop of ir.properties) {
+        if (prop.personEntity) {
+            for (const field of prop.personEntity.fields) {
+                for (const header of field.source.csvHeaders) {
+                    if (!valueByHeader.has(header))
+                        valueByHeader.set(header, sampleValueForHeader(header));
+                }
+            }
+            continue;
+        }
+        for (const header of prop.source.csvHeaders) {
+            if (!valueByHeader.has(header))
+                valueByHeader.set(header, sampleValueForHeader(header, prop.type));
+        }
+    }
+    const headerLine = headers.map(csvEscape).join(",");
+    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
+            ? {
+                entity: p.personEntity.entity,
+                fields: p.personEntity.fields.map((field) => ({
+                    path: field.path,
+                    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,
+    }));
+    const schemaPropertyLines = properties
+        .map((p) => {
+        const labels = p.labels.length > 0
+            ? `new List<string> { ${p.labels.map((l) => JSON.stringify(l)).join(", ")} }`
+            : null;
+        const aliases = p.aliases.length > 0
+            ? `new List<string> { ${p.aliases.map((a) => JSON.stringify(a)).join(", ")} }`
+            : "null";
+        const additionalDataEntries = [];
+        if (p.description)
+            additionalDataEntries.push(`                        ["description"] = ${JSON.stringify(p.description)},`);
+        if (labels)
+            additionalDataEntries.push(`                        ["labels"] = ${labels},`);
+        const additionalDataBlock = additionalDataEntries.length > 0
+            ? [
+                "                    AdditionalData = new Dictionary<string, object>",
+                "                    {",
+                ...additionalDataEntries,
+                "                    },",
+            ]
+            : [];
+        const lines = [
+            "                new Property",
+            "                {",
+            `                    Name = ${JSON.stringify(p.name)},`,
+            `                    Type = PropertyType.${p.graphTypeEnumName},`,
+        ];
+        if (p.search.searchable !== undefined)
+            lines.push(`                    IsSearchable = ${p.search.searchable ? "true" : "false"},`);
+        if (p.search.queryable !== undefined)
+            lines.push(`                    IsQueryable = ${p.search.queryable ? "true" : "false"},`);
+        if (p.search.retrievable !== undefined)
+            lines.push(`                    IsRetrievable = ${p.search.retrievable ? "true" : "false"},`);
+        if (p.search.refinable !== undefined)
+            lines.push(`                    IsRefinable = ${p.search.refinable ? "true" : "false"},`);
+        if (p.search.exactMatchRequired !== undefined)
+            lines.push(`                    IsExactMatchRequired = ${p.search.exactMatchRequired ? "true" : "false"},`);
+        if (aliases !== "null")
+            lines.push(`                    Aliases = ${aliases},`);
+        lines.push(...additionalDataBlock);
+        lines.push("                },");
+        return lines.join("\n");
+    })
+        .join("\n");
+    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}`;
+    })
+        .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
+        .flatMap((p) => {
+        const lines = [];
+        const odataType = toOdataCollectionType(p.type);
+        if (odataType) {
+            lines.push(`                { ${JSON.stringify(`${p.name}@odata.type`)}, ${JSON.stringify(odataType)} },`);
+        }
+        lines.push(`                { ${JSON.stringify(p.name)}, ${toCsPropertyValueExpression(p.type, p.csName)} },`);
+        return lines;
+    })
+        .join("\n");
+    const itemIdProperty = properties.find((p) => p.name === ir.item.idPropertyName);
+    const itemIdExpression = itemIdProperty ? `Convert.ToString(item.${itemIdProperty.csName}) ?? ""` : "\"\"";
+    const contentBlock = ir.item.contentPropertyName
+        ? [
+            "        externalItem.Content = new ExternalItemContent",
+            "        {",
+            "            Type = ExternalItemContentType.Text,",
+            `            Value = Convert.ToString(item.${toCsIdentifier(ir.item.contentPropertyName)}) ?? string.Empty,`,
+            "        };",
+        ].join("\n")
+        : "";
+    await writeFile(path.join(outDir, "Schema", "Model.cs"), await renderTemplate("dotnet/Generated/Model.cs.ejs", {
+        namespaceName,
+        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,
+        graphApiVersion: ir.connection.graphApiVersion,
+        contentCategory: ir.connection.contentCategory ?? null,
+        profileSourceWebUrl: ir.connection.profileSource?.webUrl ?? null,
+        profileSourceDisplayName: ir.connection.profileSource?.displayName ?? null,
+        profileSourcePriority: ir.connection.profileSource?.priority ?? null,
+        itemTypeName: ir.item.typeName,
+        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,
+        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", {
+        namespaceName,
+        constructorArgLines,
+    }), "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,
+        }), "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", {
+        namespaceName,
+        itemIdExpression,
+        propertiesObjectLines,
+        contentBlock,
+        graphApiVersion: ir.connection.graphApiVersion,
+    }), "utf8");
+}
+function formatValidationErrors(ir) {
+    const issues = validateIr(ir);
+    const errors = issues.filter((i) => i.severity === "error");
+    if (errors.length === 0)
+        return "";
+    return errors
+        .map((e) => `- ${e.message}${e.hint ? `\n  hint: ${e.hint}` : ""}`)
+        .join("\n");
+}
+export async function updateTsProject(options) {
+    const outDir = path.resolve(options.outDir);
+    const { config } = await loadProjectConfig(outDir);
+    const tspPath = options.tspPath ? path.resolve(options.tspPath) : path.resolve(outDir, config.tsp);
+    if (config.lang !== "ts") {
+        throw new Error(`This project is '${config.lang}'. Use cocogen init/update for that language.`);
+    }
+    const ir = await loadIrFromTypeSpec(tspPath);
+    if (ir.connection.graphApiVersion === "beta" && !options.usePreviewFeatures) {
+        throw new Error("This schema requires Graph beta. Re-run with --use-preview-features.");
+    }
+    const validationMessage = formatValidationErrors(ir);
+    if (validationMessage) {
+        throw new Error(`Schema validation failed:\n${validationMessage}`);
+    }
+    await writeGeneratedTs(outDir, ir);
+    if (options.tspPath) {
+        await writeFile(path.join(outDir, COCOGEN_CONFIG_FILE), projectConfigContents(outDir, tspPath, "ts"), "utf8");
+    }
+    return { outDir, ir };
+}
+export async function updateDotnetProject(options) {
+    const outDir = path.resolve(options.outDir);
+    const { config } = await loadProjectConfig(outDir);
+    const tspPath = options.tspPath ? path.resolve(options.tspPath) : path.resolve(outDir, config.tsp);
+    if (config.lang !== "dotnet") {
+        throw new Error(`This project is '${config.lang}'. Use cocogen init/update for that language.`);
+    }
+    const ir = await loadIrFromTypeSpec(tspPath);
+    if (ir.connection.graphApiVersion === "beta" && !options.usePreviewFeatures) {
+        throw new Error("This schema requires Graph beta. Re-run with --use-preview-features.");
+    }
+    const validationMessage = formatValidationErrors(ir);
+    if (validationMessage) {
+        throw new Error(`Schema validation failed:\n${validationMessage}`);
+    }
+    const namespaceName = toCsNamespace(path.basename(outDir));
+    await writeGeneratedDotnet(outDir, ir, namespaceName);
+    if (options.tspPath) {
+        await writeFile(path.join(outDir, COCOGEN_CONFIG_FILE), projectConfigContents(outDir, tspPath, "dotnet"), "utf8");
+    }
+    return { outDir, ir };
+}
+export async function updateProject(options) {
+    const outDir = path.resolve(options.outDir);
+    const { config } = await loadProjectConfig(outDir);
+    if (config.lang === "dotnet") {
+        return updateDotnetProject(options);
+    }
+    return updateTsProject(options);
+}
+export async function initTsProject(options) {
+    const outDir = path.resolve(options.outDir);
+    await ensureEmptyDir(outDir, Boolean(options.force));
+    const ir = await loadIrFromTypeSpec(options.tspPath);
+    if (ir.connection.graphApiVersion === "beta" && !options.usePreviewFeatures) {
+        throw new Error("This schema requires Graph beta. Re-run with --use-preview-features.");
+    }
+    const validationMessage = formatValidationErrors(ir);
+    if (validationMessage) {
+        throw new Error(`Schema validation failed:\n${validationMessage}`);
+    }
+    const projectName = options.projectName ?? path.basename(outDir);
+    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 writeFile(path.join(outDir, "package.json"), await renderTemplate("ts/package.json.ejs", {
+        projectName,
+        isPeopleConnector: ir.connection.contentCategory === "people",
+    }), "utf8");
+    await writeFile(path.join(outDir, "tspconfig.yaml"), await renderTemplate("ts/tspconfig.yaml.ejs", {}), "utf8");
+    await writeFile(path.join(outDir, "tsconfig.json"), await renderTemplate("ts/tsconfig.json.ejs", {}), "utf8");
+    await writeFile(path.join(outDir, ".env.example"), await renderTemplate("ts/.env.example.ejs", {
+        itemTypeName: ir.item.typeName,
+        isPeopleConnector: ir.connection.contentCategory === "people",
+        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");
+    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");
+    const propertiesObjectLines = ir.properties
+        .flatMap((p) => {
+        const lines = [];
+        const odataType = toOdataCollectionType(p.type);
+        if (odataType) {
+            lines.push(`      ${JSON.stringify(`${p.name}@odata.type`)}: ${JSON.stringify(odataType)},`);
+        }
+        lines.push(`      ${JSON.stringify(p.name)}: item.${p.name},`);
+        return lines;
+    })
+        .join("\n");
+    const contentBlock = ir.item.contentPropertyName
+        ? `,\n    content: {\n      type: \"text\",\n      value: String((item as any)[contentPropertyName ?? \"\"] ?? \"\"),\n    }`
+        : "";
+    await writeFile(path.join(outDir, "src", "cli.ts"), await renderTemplate("ts/src/cli.ts.ejs", {
+        graphBaseUrl: graphBaseUrl(ir),
+        isPeopleConnector: ir.connection.contentCategory === "people",
+    }), "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");
+    return { outDir, ir };
+}
+export async function initDotnetProject(options) {
+    const outDir = path.resolve(options.outDir);
+    await ensureEmptyDir(outDir, Boolean(options.force));
+    const ir = await loadIrFromTypeSpec(options.tspPath);
+    if (ir.connection.graphApiVersion === "beta" && !options.usePreviewFeatures) {
+        throw new Error("This schema requires Graph beta. Re-run with --use-preview-features.");
+    }
+    const validationMessage = formatValidationErrors(ir);
+    if (validationMessage) {
+        throw new Error(`Schema validation failed:\n${validationMessage}`);
+    }
+    const projectName = options.projectName ?? path.basename(outDir);
+    const namespaceName = toCsNamespace(projectName);
+    await mkdir(path.join(outDir, "Datasource"), { recursive: true });
+    await mkdir(path.join(outDir, "Schema"), { recursive: true });
+    await writeFile(path.join(outDir, `${projectName}.csproj`), await renderTemplate("dotnet/project.csproj.ejs", {
+        graphApiVersion: ir.connection.graphApiVersion,
+    }), "utf8");
+    await writeFile(path.join(outDir, "package.json"), await renderTemplate("dotnet/package.json.ejs", {
+        projectName,
+    }), "utf8");
+    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,
+        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, "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",
+        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, ".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");
+    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);
+    return { outDir, ir };
+}
+//# sourceMappingURL=init.js.map