@wictorwilen/cocogen 1.0.50 → 1.1.0-preview.2

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

@@ -1,3 +1,6 @@
+import { Client, ResponseType } from "@microsoft/microsoft-graph-client";
+import type { AuthenticationProvider } from "@microsoft/microsoft-graph-client";
+
 import type { ItemSource } from "../datasource/itemSource.js";
 
 type ProfileSourceOptions = {
@@ -7,7 +10,12 @@ type ProfileSourceOptions = {
 };
 
 export type ConnectorCoreOptions<Item> = {
-  graphBaseUrl: string;
+  graphBaseUrls: {
+    connectionProvisioning: string;
+    schemaRegistration: string;
+    itemIngestion: string;
+    profileSourceRegistration: string;
+  };
   contentCategory: string | null;
   schemaPayload: unknown;
   getAccessToken: () => Promise<string>;
@@ -32,6 +40,7 @@ export type IngestOptions<Item> = {
   connectionId: string;
   dryRun?: boolean;
   limit?: number;
+  batchSize?: number;
   verbose?: boolean;
   failFast?: boolean;
   toExternalItem: (item: Item) => unknown;
@@ -41,7 +50,13 @@ export type IngestOptions<Item> = {
  * Reusable connector core for provisioning, ingestion, and deletion.
  */
 export class ConnectorCore<Item> {
-  private readonly graphBaseUrl: string;
+  private readonly graphClient: Client;
+  private readonly graphBaseUrls: {
+    connectionProvisioning: string;
+    schemaRegistration: string;
+    itemIngestion: string;
+    profileSourceRegistration: string;
+  };
   private readonly contentCategory: string | null;
   private readonly schemaPayload: unknown;
   private readonly getAccessToken: () => Promise<string>;
@@ -55,13 +70,18 @@ export class ConnectorCore<Item> {
   private readonly profileSource?: ProfileSourceOptions;
 
   constructor(options: ConnectorCoreOptions<Item>) {
-    this.graphBaseUrl = options.graphBaseUrl;
+    this.graphBaseUrls = options.graphBaseUrls;
     this.contentCategory = options.contentCategory;
     this.schemaPayload = options.schemaPayload;
     this.getAccessToken = options.getAccessToken;
     this.getItemId = options.getItemId;
     this.toExternalItem = options.toExternalItem;
     this.profileSource = options.profileSource;
+
+    const authProvider: AuthenticationProvider = {
+      getAccessToken: async () => this.getAccessToken(),
+    };
+    this.graphClient = Client.initWithMiddleware({ authProvider });
   }
 
   /**
@@ -71,7 +91,7 @@ export class ConnectorCore<Item> {
     console.log("info: ensuring connection exists...");
     const existing = await this.graphRequest(
       "GET",
-      `${this.graphBaseUrl}/external/connections/${options.connectionId}`
+      `${this.graphBaseUrls.connectionProvisioning}/external/connections/${options.connectionId}`
     );
     if (existing.ok) {
       console.log("ok: connection exists");
@@ -90,7 +110,7 @@ export class ConnectorCore<Item> {
 
     if (this.contentCategory) payload.contentCategory = this.contentCategory;
 
-    const createUrl = `${this.graphBaseUrl}/external/connections`;
+    const createUrl = `${this.graphBaseUrls.connectionProvisioning}/external/connections`;
     const create = await this.graphRequest("POST", createUrl, payload);
     if (!create.ok && create.status !== 409) {
       const details = await readGraphError(create);
@@ -109,7 +129,7 @@ export class ConnectorCore<Item> {
    */
   async patchSchema(connectionId: string): Promise<void> {
     console.log("info: patching schema...");
-    const schemaUrl = `${this.graphBaseUrl}/external/connections/${connectionId}/schema`;
+    const schemaUrl = `${this.graphBaseUrls.schemaRegistration}/external/connections/${connectionId}/schema`;
     const res = await this.graphRequest("PATCH", schemaUrl, this.schemaPayload);
     if (!res.ok) {
       const details = await readGraphError(res);
@@ -165,7 +185,10 @@ export class ConnectorCore<Item> {
     }
 
     console.log("info: deleting connection...");
-    const res = await this.graphRequest("DELETE", `${this.graphBaseUrl}/external/connections/${connectionId}`);
+    const res = await this.graphRequest(
+      "DELETE",
+      `${this.graphBaseUrls.connectionProvisioning}/external/connections/${connectionId}`
+    );
     if (!res.ok && res.status !== 404) {
       const details = await readGraphError(res);
       throw new Error(`Failed to delete connection (HTTP ${formatStatus(res)}): ${details}`);
@@ -177,7 +200,7 @@ export class ConnectorCore<Item> {
    */
   async putItem(connectionId: string, item: Item, verbose: boolean): Promise<void> {
     const itemId = this.getItemId(item);
-    const url = `${this.graphBaseUrl}/external/connections/${connectionId}/items/${encodeURIComponent(itemId)}`;
+    const url = `${this.graphBaseUrls.itemIngestion}/external/connections/${connectionId}/items/${encodeURIComponent(itemId)}`;
 
     const payload = this.toExternalItem(item);
     const payloadWithId = {
@@ -202,25 +225,66 @@ export class ConnectorCore<Item> {
    * Ingest items from a datasource.
    */
   async ingest(options: IngestOptions<Item>): Promise<void> {
+    const batchSize = options.batchSize ?? 1;
+    if (!Number.isInteger(batchSize) || batchSize < 1 || batchSize > 20) {
+      throw new Error("Invalid batch size: expected integer between 1 and 20.");
+    }
+
     let count = 0;
     let successCount = 0;
     const failures: Array<{ index: number; id: string; message: string }> = [];
+    const pending: Array<{ index: number; id: string; item: Item }> = [];
+
+    const flushBatch = async (): Promise<void> => {
+      if (pending.length === 0) {
+        return;
+      }
+
+      for (const entry of pending) {
+        console.log(`info: ingesting item ${entry.index} (id=${entry.id})`);
+      }
+
+      const currentBatch = pending.splice(0, pending.length);
+      const results = await Promise.all(
+        currentBatch.map(async (entry) => {
+          try {
+            await this.putItem(options.connectionId, entry.item, Boolean(options.verbose));
+            return { ...entry, success: true as const };
+          } catch (error) {
+            return { ...entry, success: false as const, error };
+          }
+        })
+      );
+
+      let firstError: unknown = null;
+      for (const result of results) {
+        if (result.success) {
+          console.log(`ok: ingested item ${result.index} (id=${result.id})`);
+          successCount++;
+          continue;
+        }
+
+        const message = result.error instanceof Error ? result.error.message : String(result.error);
+        console.error(`error: failed item ${result.index} (id=${result.id})`);
+        failures.push({ index: result.index, id: result.id, message });
+        if (options.failFast && firstError === null) {
+          firstError = result.error;
+        }
+      }
+
+      if (firstError !== null) {
+        throw firstError;
+      }
+    };
+
     for await (const item of options.source.getItems()) {
       if (options.limit && count >= options.limit) break;
+      const index = count + 1;
       const itemId = this.getItemId(item as Item);
       if (!options.dryRun) {
-        console.log(`info: ingesting item ${count + 1} (id=${itemId})`);
-        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})`);
-          failures.push({ index: count + 1, id: itemId, message });
-          if (options.failFast) {
-            throw error;
-          }
+        pending.push({ index, id: itemId, item: item as Item });
+        if (pending.length >= batchSize) {
+          await flushBatch();
         }
       } else if (options.verbose) {
         const payload = options.toExternalItem(item as Item) as any;
@@ -229,11 +293,15 @@ export class ConnectorCore<Item> {
           id: itemId,
           content: payload?.content ?? { type: "text", value: "" },
         };
-        console.log(`verbose: DRY RUN item ${count + 1} (id=${itemId})`, JSON.stringify(payloadWithId, null, 2));
+        console.log(`verbose: DRY RUN item ${index} (id=${itemId})`, JSON.stringify(payloadWithId, null, 2));
       }
       count++;
     }
 
+    if (!options.dryRun) {
+      await flushBatch();
+    }
+
     if (!options.dryRun) {
       console.log(`ok: ingested ${successCount} item(s)`);
     } else {
@@ -250,33 +318,38 @@ export class ConnectorCore<Item> {
 
   private async graphRequest(method: string, url: string, body?: unknown): Promise<Response> {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-      const token = await this.getAccessToken();
-      const res = await fetch(url, {
-        method,
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json",
-        },
-        body: body ? JSON.stringify(body) : undefined,
-      });
-
-      if (!shouldRetry(res.status) || attempt === MAX_RETRIES) {
-        return res;
-      }
+      try {
+        const request = this.graphClient.api(url).responseType(ResponseType.RAW);
+        const response = await executeGraphRequest(request, method, body);
+        if (!shouldRetryStatus(response.status) || attempt === MAX_RETRIES) {
+          return response;
+        }
 
-      const retryAfterMs = parseRetryAfter(res.headers.get("Retry-After"));
-      const delay = computeDelay(attempt, retryAfterMs);
-      console.warn(`warn: throttled (HTTP ${res.status}) for ${url}, retrying in ${delay}ms`);
-      await sleep(delay);
+        const delay = computeRetryDelayMs(attempt, response.headers);
+        console.warn(`warn: throttled (HTTP ${formatStatus(response)}) for ${method} ${url}, retrying in ${delay}ms`);
+        await sleep(delay);
+      } catch (error) {
+        if (!isRetryableTransportError(error) || attempt === MAX_RETRIES) {
+          throw error;
+        }
+
+        const delay = computeRetryDelayMs(attempt);
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`warn: transient Graph transport error for ${method} ${url}: ${message}. Retrying in ${delay}ms`);
+        await sleep(delay);
+      }
     }
 
-    throw new Error("Failed to send request after retries.");
+    throw new Error(`Graph request '${method} ${url}' exhausted retries.`);
   }
 
   private async listProfilePropertySettings(): Promise<
     Array<{ id: string; name?: string; prioritizedSourceUrls: string[] }>
   > {
-    const res = await this.graphRequest("GET", `${this.graphBaseUrl}/admin/people/profilePropertySettings`);
+    const res = await this.graphRequest(
+      "GET",
+      `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profilePropertySettings`
+    );
     if (!res.ok) {
       const details = await readGraphError(res);
       throw new Error(`Failed to list profile property settings (HTTP ${formatStatus(res)}): ${details}`);
@@ -294,7 +367,10 @@ export class ConnectorCore<Item> {
   }
 
   private async listProfileSources(): Promise<Array<{ sourceId: string }>> {
-    const res = await this.graphRequest("GET", `${this.graphBaseUrl}/admin/people/profileSources`);
+    const res = await this.graphRequest(
+      "GET",
+      `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profileSources`
+    );
     if (!res.ok) {
       const details = await readGraphError(res);
       throw new Error(`Failed to list profile sources (HTTP ${formatStatus(res)}): ${details}`);
@@ -316,20 +392,24 @@ export class ConnectorCore<Item> {
         webUrl: profile.webUrl,
       };
 
-      const create = await this.graphRequest("POST", `${this.graphBaseUrl}/admin/people/profileSources`, payload);
+      const create = await this.graphRequest(
+        "POST",
+        `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profileSources`,
+        payload
+      );
       if (!create.ok && create.status !== 409) {
         const details = await readGraphError(create);
         throw new Error(`Failed to register profile source (HTTP ${formatStatus(create)}): ${details}`);
       }
     }
 
-    const sourceUrl = `${this.graphBaseUrl}/admin/people/profileSources(sourceId='${connectionId}')`;
+    const sourceUrl = `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profileSources(sourceId='${connectionId}')`;
     const settings = await this.listProfilePropertySettings();
     const precedence = settings.find((setting) => !setting.name);
     if (!precedence) {
       const create = await this.graphRequest(
         "POST",
-        `${this.graphBaseUrl}/admin/people/profilePropertySettings`,
+        `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profilePropertySettings`,
         { prioritizedSourceUrls: [sourceUrl] }
       );
       if (!create.ok) {
@@ -353,7 +433,7 @@ export class ConnectorCore<Item> {
       : this.uniqueUrls([...existing, sourceUrl]);
     const res = await this.graphRequest(
       "PATCH",
-      `${this.graphBaseUrl}/admin/people/profilePropertySettings/${precedence.id}`,
+      `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profilePropertySettings/${precedence.id}`,
       {
         prioritizedSourceUrls: updated,
       }
@@ -365,7 +445,7 @@ export class ConnectorCore<Item> {
   }
 
   private async unregisterProfileSourceInternal(connectionId: string): Promise<void> {
-    const sourceUrl = `${this.graphBaseUrl}/admin/people/profileSources(sourceId='${connectionId}')`;
+    const sourceUrl = `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profileSources(sourceId='${connectionId}')`;
     const settings = await this.listProfilePropertySettings();
     const precedence = settings.find((setting) => !setting.name);
     if (precedence) {
@@ -374,7 +454,7 @@ export class ConnectorCore<Item> {
         const updated = current.filter((value) => value !== sourceUrl);
         const res = await this.graphRequest(
           "PATCH",
-          `${this.graphBaseUrl}/admin/people/profilePropertySettings/${precedence.id}`,
+          `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profilePropertySettings/${precedence.id}`,
           {
             prioritizedSourceUrls: updated,
           }
@@ -388,7 +468,7 @@ export class ConnectorCore<Item> {
 
     const res = await this.graphRequest(
       "DELETE",
-      `${this.graphBaseUrl}/admin/people/profileSources(sourceId='${connectionId}')`
+      `${this.graphBaseUrls.profileSourceRegistration}/admin/people/profileSources(sourceId='${connectionId}')`
     );
     if (!res.ok && res.status !== 404) {
       const details = await readGraphError(res);
@@ -409,7 +489,7 @@ export class ConnectorCore<Item> {
   }
 
   private async waitForSchemaReady(connectionId: string): Promise<void> {
-    const schemaUrl = `${this.graphBaseUrl}/external/connections/${connectionId}/schema`;
+    const schemaUrl = `${this.graphBaseUrls.schemaRegistration}/external/connections/${connectionId}/schema`;
     console.log("info: waiting for schema provisioning...");
     for (let attempt = 0; attempt < SCHEMA_POLL_MAX_ATTEMPTS; attempt++) {
       const res = await this.graphRequest("GET", schemaUrl);
@@ -433,11 +513,11 @@ export class ConnectorCore<Item> {
   }
 }
 
-const MAX_RETRIES = 6;
-const BASE_DELAY_MS = 1000;
-const MAX_DELAY_MS = 30000;
 const SCHEMA_POLL_MAX_ATTEMPTS = 12;
 const SCHEMA_POLL_DELAY_MS = 30000;
+const MAX_RETRIES = 6;
+const BASE_RETRY_DELAY_MS = 1000;
+const MAX_RETRY_DELAY_MS = 30000;
 const SCHEMA_READY_STATES = new Set(["completed", "ready", "succeeded", "success"]);
 const SCHEMA_PENDING_STATES = new Set(["inprogress", "pending", "running", "updating"]);
 
@@ -445,35 +525,92 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function parseRetryAfter(value: string | null): number | null {
-  if (!value) return null;
-  const seconds = Number(value);
-  if (!Number.isNaN(seconds) && Number.isFinite(seconds)) {
-    return Math.max(0, seconds * 1000);
+function formatStatus(res: Response): string {
+  const text = res.statusText?.trim();
+  return text ? `${res.status} ${text}` : `${res.status}`;
+}
+
+async function executeGraphRequest(
+  request: ReturnType<Client["api"]>,
+  method: string,
+  body?: unknown
+): Promise<Response> {
+  switch (method) {
+    case "GET":
+      return (await request.get()) as Response;
+    case "POST":
+      return (await request.post(body ?? {})) as Response;
+    case "PATCH":
+      return (await request.patch(body ?? {})) as Response;
+    case "PUT":
+      return (await request.put(body ?? {})) as Response;
+    case "DELETE":
+      return (await request.delete()) as Response;
+    default:
+      throw new Error(`Unsupported Graph method '${method}'.`);
   }
+}
+
+function shouldRetryStatus(status: number): boolean {
+  return status === 408 || status === 429 || (status >= 500 && status <= 599);
+}
 
-  const dateMs = Date.parse(value);
-  if (!Number.isNaN(dateMs)) {
-    return Math.max(0, dateMs - Date.now());
+function isRetryableTransportError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
   }
 
-  return null;
+  const message = error.message.toLowerCase();
+  return message.includes("fetch")
+    || message.includes("network")
+    || message.includes("timeout")
+    || message.includes("socket")
+    || message.includes("econnreset")
+    || message.includes("econnrefused")
+    || message.includes("etimedout")
+    || message.includes("temporary failure");
 }
 
-function computeDelay(attempt: number, retryAfter: number | null): number {
-  if (retryAfter !== null) return Math.min(retryAfter, MAX_DELAY_MS);
-  const exp = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
+function computeRetryDelayMs(attempt: number, headers?: Headers): number {
+  const retryAfterMs = parseRetryDelayMs(headers);
+  if (retryAfterMs !== null) {
+    return Math.min(retryAfterMs, MAX_RETRY_DELAY_MS);
+  }
+
+  const exponential = Math.min(MAX_RETRY_DELAY_MS, BASE_RETRY_DELAY_MS * 2 ** attempt);
   const jitter = Math.floor(Math.random() * 250);
-  return Math.min(MAX_DELAY_MS, exp + jitter);
+  return Math.min(MAX_RETRY_DELAY_MS, exponential + jitter);
 }
 
-function shouldRetry(status: number): boolean {
-  return status === 429 || status === 503 || status === 504;
-}
+function parseRetryDelayMs(headers?: Headers): number | null {
+  if (!headers) {
+    return null;
+  }
 
-function formatStatus(res: Response): string {
-  const text = res.statusText?.trim();
-  return text ? `${res.status} ${text}` : `${res.status}`;
+  const msHeader = headers.get("x-ms-retry-after-ms")?.trim();
+  if (msHeader) {
+    const milliseconds = Number.parseInt(msHeader, 10);
+    if (Number.isFinite(milliseconds)) {
+      return Math.max(0, milliseconds);
+    }
+  }
+
+  const retryAfter = headers.get("Retry-After")?.trim();
+  if (!retryAfter) {
+    return null;
+  }
+
+  const seconds = Number.parseInt(retryAfter, 10);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1000);
+  }
+
+  const absolute = Date.parse(retryAfter);
+  if (Number.isFinite(absolute)) {
+    return Math.max(0, absolute - Date.now());
+  }
+
+  return null;
 }
 
 async function readGraphError(res: Response): Promise<string> {

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

@@ -2,9 +2,22 @@
  * Graph people entity helpers (generated).
  */
 
+<% const hasLocalGraphTypes = graphTypes.some((type) => !type.sourcePackage); -%>
+
 type UnknownObject = { [key: string]: unknown };
 
+<% if (hasLocalGraphTypes) { -%>
 type Open<T> = T & Record<string, unknown>;
+<% } -%>
+
+<% const usesStableGraphTypes = graphTypes.some((type) => type.sourcePackage === "v1"); -%>
+<% const usesBetaGraphTypes = graphTypes.some((type) => type.sourcePackage === "beta"); -%>
+<% if (usesStableGraphTypes) { -%>
+import type * as MicrosoftGraph from "@microsoft/microsoft-graph-types";
+<% } -%>
+<% if (usesBetaGraphTypes) { -%>
+import type * as MicrosoftGraphBeta from "@microsoft/microsoft-graph-types-beta";
+<% } -%>
 
 const isRecord = (value: unknown): value is UnknownObject =>
   typeof value === "object" && value !== null && !Array.isArray(value);
@@ -65,7 +78,88 @@ const normalizeCollectionValue = (
   return results;
 };
 
-<% if (graphEnums && graphEnums.length > 0) { -%>
+const ITEM_FACET_READ_ONLY_KEYS = [
+  "createdBy",
+  "createdDateTime",
+  "lastModifiedBy",
+  "lastModifiedDateTime",
+  "source",
+  "sources",
+] as const;
+
+const assertWritableItemFacet = (value: UnknownObject, fieldPath: string): void => {
+  if (value["id"] !== undefined) {
+    throw new Error(fieldPath + ".id is read-only and must not be provided.");
+  }
+  for (const key of ITEM_FACET_READ_ONLY_KEYS) {
+    if (value[key] !== undefined) {
+      throw new Error(fieldPath + "." + key + " is read-only and must not be provided.");
+    }
+  }
+};
+
+const validateSdkGraphObject = <T>(
+  value: unknown,
+  fieldPath: string,
+  disallowReadonlyItemFacetFields = false
+): T => {
+  if (!isRecord(value)) {
+    throw new Error(`${fieldPath} must be an object.`);
+  }
+  if (disallowReadonlyItemFacetFields) {
+    assertWritableItemFacet(value, fieldPath);
+  }
+  return value as T;
+};
+
+const serializeSdkSingleValue = <T>(
+  value: unknown,
+  fieldName: string,
+  disallowReadonlyItemFacetFields = false
+): string | undefined => {
+  const payload = normalizeSingleValue(value, fieldName);
+  if (!payload) return undefined;
+  return JSON.stringify(validateSdkGraphObject<T>(payload, fieldName, disallowReadonlyItemFacetFields));
+};
+
+const serializeSdkCollectionValue = <T>(
+  payloads: Array<UnknownObject>,
+  fieldName: string,
+  disallowReadonlyItemFacetFields = false
+): string[] =>
+  payloads.map((payload, index) =>
+    JSON.stringify(
+      validateSdkGraphObject<T>(payload, `${fieldName}[${index}]`, disallowReadonlyItemFacetFields)
+    )
+  );
+
+type PeopleLabelSerializationOptions = {
+  isCollection: boolean;
+  collectionLimit: number | null;
+  disallowReadonlyItemFacetFields: boolean;
+};
+
+export function serializeSdkPeopleLabelValue<T>(
+  value: unknown,
+  fieldName: string,
+  options: PeopleLabelSerializationOptions
+): string | string[] | undefined {
+  if (options.isCollection) {
+    const payloads = normalizeCollectionValue(value, fieldName);
+    if (!payloads) return undefined;
+    if (payloads.length === 0) return [];
+    if (options.collectionLimit !== null && payloads.length > options.collectionLimit) {
+      throw new Error(
+        `${fieldName} supports at most ${options.collectionLimit} entries (received ${payloads.length}).`
+      );
+    }
+    return serializeSdkCollectionValue<T>(payloads, fieldName, options.disallowReadonlyItemFacetFields);
+  }
+
+  return serializeSdkSingleValue<T>(value, fieldName, options.disallowReadonlyItemFacetFields);
+}
+
+<% if (hasLocalGraphTypes && graphEnums && graphEnums.length > 0) { -%>
 <% for (const enumDef of graphEnums) { -%>
 export type <%= enumDef.tsName %> =
 <% for (const value of enumDef.values) { -%>
@@ -86,6 +180,7 @@ const is<%= enumDef.tsName %> = (value: unknown): value is <%= enumDef.tsName %>
 <% } -%>
 
 <% for (const type of graphTypes) { -%>
+<% if (!type.sourcePackage) { -%>
 export type <%= type.alias %> = Open<
 <% if (type.baseAlias) { -%>
   <%= type.baseAlias %> &
@@ -97,6 +192,9 @@ export type <%= type.alias %> = Open<
 }
 >;
 
+<% } -%>
+
+<% if (!type.sourcePackage) { -%>
 export function validate<%= type.alias %>(value: unknown, fieldPath: string): <%= type.alias %> {
 <% if (type.baseAlias) { -%>
   validate<%= type.baseAlias %>(value, fieldPath);
@@ -141,31 +239,5 @@ export function validate<%= type.alias %>(value: unknown, fieldPath: string): <%
 }
 
 <% } -%>
-<% for (const label of labels) { -%>
-export function <%= label.serializerName %>(
-  value: unknown,
-  fieldName = <%= JSON.stringify(label.label) %>
-): <%= label.isCollection ? "string[] | undefined" : "string | undefined" %> {
-<% if (label.isCollection) { -%>
-  const payloads = normalizeCollectionValue(value, fieldName);
-  if (!payloads) return undefined;
-  if (payloads.length === 0) return [];
-<% if (label.collectionLimit) { -%>
-  if (payloads.length > <%= label.collectionLimit %>) {
-    throw new Error(
-      `${fieldName} supports at most <%= label.collectionLimit %> entries (received ${"${payloads.length}"}).`
-    );
-  }
-<% } -%>
-  return payloads.map((payload, index) =>
-    JSON.stringify(validate<%= label.graphTypeAlias %>(payload, `${fieldName}[${"${index}"}]`))
-  );
-<% } else { -%>
-  const payload = normalizeSingleValue(value, fieldName);
-  if (!payload) return undefined;
-  const validated = validate<%= label.graphTypeAlias %>(payload, fieldName);
-  return JSON.stringify(validated);
-<% } -%>
-}
 
 <% } -%>

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

@@ -3,13 +3,13 @@
  */
 export type Principal = {
   "@odata.type": "#microsoft.graph.externalConnectors.principal";
-  externalName?: string;
-  externalId?: string;
+  email?: string;
   entraDisplayName?: string;
   entraId?: string;
-  email?: string;
-  upn?: string;
+  externalId?: string;
+  externalName?: string;
   tenantId?: string;
+  upn?: string;
   [key: string]: string | undefined;
 };
 

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

@@ -4,6 +4,15 @@
  */
 export const graphApiVersion = <%= JSON.stringify(graphApiVersion) %> as const;
 /** Graph API version used by the connector. */
+export const graphOperationVersions = <%- JSON.stringify(graphOperationVersions, null, 2) %> as const;
+/** Graph API version used for each connector operation. */
+export const graphBaseUrls = {
+	connectionProvisioning: `https://graph.microsoft.com/${graphOperationVersions.connectionProvisioning}`,
+	schemaRegistration: `https://graph.microsoft.com/${graphOperationVersions.schemaRegistration}`,
+	itemIngestion: `https://graph.microsoft.com/${graphOperationVersions.itemIngestion}`,
+	profileSourceRegistration: `https://graph.microsoft.com/${graphOperationVersions.profileSourceRegistration}`,
+} as const;
+/** Graph base URLs used for each connector operation. */
 export const contentCategory: string | null = <%= JSON.stringify(contentCategory) %>;
 /** Optional content category for the connection. */
 export const connectionName: string | null = <%= JSON.stringify(connectionName) %>;