@mustafaaksoy41/sharepoint-kit 0.1.2

package/dist/bin/sp-generate-types.js

@@ -0,0 +1,784 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// bin/sp-generate-types.ts
+import { Command } from "commander";
+
+// src/cli/generate-types.ts
+import { writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { ConfidentialClientApplication } from "@azure/msal-node";
+
+// src/cli/config-loader.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, extname } from "path";
+async function loadConfig(configPath) {
+  const absolutePath = resolve(process.cwd(), configPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const ext = extname(absolutePath);
+  let config;
+  if (ext === ".json") {
+    const content = readFileSync(absolutePath, "utf-8");
+    config = JSON.parse(content);
+  } else if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+    const module = await import(absolutePath);
+    config = module.default ?? module;
+  } else {
+    throw new Error(`Unsupported config file format: ${ext}. Use .json, .ts, .js, or .mjs`);
+  }
+  validateConfig(config);
+  return config;
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Config must be an object");
+  }
+  const c = config;
+  if (!c.siteId || typeof c.siteId !== "string") {
+    throw new Error('Config must have a "siteId" string property');
+  }
+  if (!Array.isArray(c.contentTypes) || c.contentTypes.length === 0) {
+    throw new Error('Config must have a non-empty "contentTypes" array');
+  }
+  for (const [index, ct] of c.contentTypes.entries()) {
+    if (!ct || typeof ct !== "object") {
+      throw new Error(`contentTypes[${index}] must be an object`);
+    }
+    const ctObj = ct;
+    if (!ctObj.contentTypeName || typeof ctObj.contentTypeName !== "string") {
+      throw new Error(`contentTypes[${index}] must have a "contentTypeName" string property`);
+    }
+    if (!ctObj.outputType || typeof ctObj.outputType !== "string") {
+      throw new Error(`contentTypes[${index}] must have an "outputType" string property`);
+    }
+    if (ctObj.listId !== void 0 && typeof ctObj.listId !== "string") {
+      throw new Error(`contentTypes[${index}].listId must be a string`);
+    }
+    if (ctObj.listName !== void 0 && typeof ctObj.listName !== "string") {
+      throw new Error(`contentTypes[${index}].listName must be a string`);
+    }
+    const validStrategies = ["interactive", "first", "error", "all"];
+    if (ctObj.strategy !== void 0 && !validStrategies.includes(ctObj.strategy)) {
+      throw new Error(`contentTypes[${index}].strategy must be one of: ${validStrategies.join(", ")}`);
+    }
+  }
+  if (c.defaultStrategy !== void 0) {
+    const validStrategies = ["interactive", "first", "error", "all"];
+    if (!validStrategies.includes(c.defaultStrategy)) {
+      throw new Error(`defaultStrategy must be one of: ${validStrategies.join(", ")}`);
+    }
+  }
+}
+
+// src/cli/cache-manager.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join } from "path";
+var CACHE_FILE = ".sharepoint-cache.json";
+var CacheManager = class {
+  constructor(outputDir = "./") {
+    this.cachePath = join(outputDir, CACHE_FILE);
+  }
+  load() {
+    if (!existsSync2(this.cachePath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync2(this.cachePath, "utf-8");
+      const data = JSON.parse(content);
+      if (!data || typeof data !== "object") return null;
+      return data;
+    } catch {
+      return null;
+    }
+  }
+  save(data) {
+    writeFileSync(this.cachePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+  getResolution(contentTypeName) {
+    const cache = this.load();
+    if (!cache) return null;
+    return cache.resolutions[contentTypeName] ?? null;
+  }
+  saveResolution(siteId, contentTypeName, listId, listName) {
+    const cache = this.load() ?? {
+      siteId,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      lists: [],
+      resolutions: {}
+    };
+    cache.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    cache.siteId = siteId;
+    cache.resolutions[contentTypeName] = {
+      listId,
+      listName,
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.save(cache);
+  }
+  saveLists(siteId, lists) {
+    const cache = this.load() ?? {
+      siteId,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      lists: [],
+      resolutions: {}
+    };
+    cache.siteId = siteId;
+    cache.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    cache.lists = lists;
+    this.save(cache);
+  }
+  clear() {
+    if (existsSync2(this.cachePath)) {
+      writeFileSync(this.cachePath, "{}", "utf-8");
+      console.log("Cache cleared.");
+    }
+  }
+  getCachePath() {
+    return this.cachePath;
+  }
+};
+
+// src/cli/interactive-prompt.ts
+import prompts from "prompts";
+async function promptListSelection(contentTypeName, lists, strategy = "interactive") {
+  if (strategy === "first") {
+    console.log(`  Using first match: "${lists[0].displayName}" (${lists[0].id})`);
+    return [{ listId: lists[0].id, listName: lists[0].displayName }];
+  }
+  if (strategy === "error") {
+    throw new Error(
+      `Content type "${contentTypeName}" found in ${lists.length} lists. Please specify listId or listName in config, or use --strategy=all`
+    );
+  }
+  if (strategy === "all") {
+    console.log(`  Generating types for ALL ${lists.length} lists`);
+    return lists.map((list) => ({
+      listId: list.id,
+      listName: list.displayName
+    }));
+  }
+  console.log(`
+  Content type "${contentTypeName}" found in ${lists.length} lists:
+`);
+  const choices = [
+    ...lists.map((list, index) => ({
+      title: `${index + 1}. ${list.displayName} (${list.id})`,
+      value: list.id,
+      description: `List ID: ${list.id}`
+    })),
+    {
+      title: `Generate types for ALL ${lists.length} lists`,
+      value: "__all__",
+      description: lists.map((l) => l.displayName).join(", ")
+    },
+    {
+      title: "Skip this content type",
+      value: "__skip__",
+      description: "Do not generate types for this content type"
+    }
+  ];
+  const response = await prompts({
+    type: "select",
+    name: "selection",
+    message: `Which list(s) should be used for "${contentTypeName}"?`,
+    choices,
+    initial: 0
+  });
+  if (!response.selection || response.selection === "__skip__") {
+    console.log(`  Skipped "${contentTypeName}"
+`);
+    return [];
+  }
+  if (response.selection === "__all__") {
+    console.log(`  Generating types for all lists
+`);
+    return lists.map((list) => ({
+      listId: list.id,
+      listName: list.displayName
+    }));
+  }
+  const selectedList = lists.find((l) => l.id === response.selection);
+  if (!selectedList) {
+    throw new Error("Invalid selection");
+  }
+  console.log(`  Selected: ${selectedList.displayName}
+`);
+  return [{ listId: response.selection, listName: selectedList.displayName }];
+}
+
+// src/cli/list-resolver.ts
+async function resolveContentType(config, siteId, graphClient, cacheManager, globalStrategy, nonInteractive) {
+  const strategy = config.strategy ?? globalStrategy;
+  if (config.listId) {
+    const list = await graphClient.getList({ listId: config.listId });
+    console.log(`  Found list "${list.displayName}" (${list.id})`);
+    return [{
+      contentTypeName: config.contentTypeName,
+      outputType: config.outputType,
+      listId: config.listId,
+      listName: list.displayName
+    }];
+  }
+  const cached = cacheManager.getResolution(config.contentTypeName);
+  if (cached) {
+    console.log(`  Using cached resolution for "${config.contentTypeName}": ${cached.listName}`);
+    return [{
+      contentTypeName: config.contentTypeName,
+      outputType: config.outputType,
+      listId: cached.listId,
+      listName: cached.listName
+    }];
+  }
+  const lists = await graphClient.getLists();
+  if (config.listName) {
+    const list = lists.find(
+      (l) => l.displayName === config.listName || l.name === config.listName
+    );
+    if (!list) {
+      throw new Error(`List "${config.listName}" not found in site "${siteId}"`);
+    }
+    console.log(`  Found list "${list.displayName}" (${list.id})`);
+    cacheManager.saveResolution(siteId, config.contentTypeName, list.id, list.displayName);
+    return [{
+      contentTypeName: config.contentTypeName,
+      outputType: config.outputType,
+      listId: list.id,
+      listName: list.displayName
+    }];
+  }
+  console.log(`  Scanning lists for content type "${config.contentTypeName}"...`);
+  const matchingLists = [];
+  for (const list of lists) {
+    try {
+      const contentTypes = await graphClient.getListContentTypes({ listId: list.id });
+      if (contentTypes.some((ct) => ct.name === config.contentTypeName)) {
+        matchingLists.push({
+          id: list.id,
+          displayName: list.displayName,
+          name: list.name
+        });
+      }
+    } catch {
+    }
+  }
+  if (matchingLists.length === 0) {
+    throw new Error(
+      `Content type "${config.contentTypeName}" not found in any list of site "${siteId}"`
+    );
+  }
+  if (matchingLists.length === 1) {
+    const list = matchingLists[0];
+    console.log(`  Found content type "${config.contentTypeName}" in list "${list.displayName}"`);
+    cacheManager.saveResolution(siteId, config.contentTypeName, list.id, list.displayName);
+    return [{
+      contentTypeName: config.contentTypeName,
+      outputType: config.outputType,
+      listId: list.id,
+      listName: list.displayName
+    }];
+  }
+  const effectiveStrategy = nonInteractive && strategy === "interactive" ? "first" : strategy;
+  const selectedLists = await promptListSelection(
+    config.contentTypeName,
+    matchingLists,
+    effectiveStrategy
+  );
+  if (selectedLists.length === 0) {
+    return [];
+  }
+  if (selectedLists.length === 1) {
+    cacheManager.saveResolution(
+      siteId,
+      config.contentTypeName,
+      selectedLists[0].listId,
+      selectedLists[0].listName
+    );
+  }
+  if (selectedLists.length > 1) {
+    return selectedLists.map((list) => ({
+      contentTypeName: config.contentTypeName,
+      outputType: `${config.outputType}_${list.listName.replace(/\s+/g, "")}`,
+      listId: list.listId,
+      listName: list.listName
+    }));
+  }
+  return selectedLists.map((list) => ({
+    contentTypeName: config.contentTypeName,
+    outputType: config.outputType,
+    listId: list.listId,
+    listName: list.listName
+  }));
+}
+
+// src/cli/templates.ts
+function generateFileHeader() {
+  return [
+    "// Auto-generated by @mustafaaksoy41/sharepoint-kit CLI",
+    "// Do not edit manually. Run: npx sp-generate-types --config sharepoint.config.ts",
+    ""
+  ].join("\n");
+}
+function generateInterface(name, fields) {
+  const lines = [];
+  lines.push(`export interface ${name} {`);
+  for (const field of fields) {
+    if (field.description) {
+      lines.push(`  /** ${field.description} */`);
+    }
+    const optional = field.required ? "" : "?";
+    lines.push(`  ${field.name}${optional}: ${field.tsType};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function mapSharePointTypeToTs(spType) {
+  switch (spType) {
+    case "Text":
+    case "Note":
+    case "Choice":
+      return "string";
+    case "MultiChoice":
+      return "string[]";
+    case "Number":
+    case "Currency":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    case "DateTime":
+      return "string";
+    case "Lookup":
+      return "{ id: number; value: string }";
+    case "User":
+      return "{ id: number; email: string; displayName: string }";
+    case "URL":
+      return "{ url: string; description: string }";
+    case "Taxonomy":
+      return "{ termGuid: string; label: string }";
+    case "Calculated":
+      return "string | number";
+    default:
+      return "unknown";
+  }
+}
+function sanitizeInterfaceName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "").replace(/^(\d)/, "_$1");
+}
+
+// src/cli/type-generator.ts
+async function generateTypeScript(inputs, graphClient, options = {}) {
+  const { fieldNameMapping = {} } = options;
+  const interfaces = [generateFileHeader()];
+  for (const input of inputs) {
+    console.log(`  Generating interface "${input.outputType}" from list "${input.listName}"...`);
+    const contentTypes = await graphClient.getListContentTypes({ listId: input.listId });
+    const contentType = contentTypes.find((ct) => ct.name === input.contentTypeName);
+    let columns;
+    if (contentType) {
+      columns = await graphClient.getColumns({ contentTypeId: contentType.id });
+    } else {
+      console.log(`    Content type not found by ID, falling back to list columns`);
+      columns = await graphClient.getListColumns({ listId: input.listId });
+    }
+    const writableColumns = columns.filter((col) => !col.readOnly && !isSystemColumn(col.name));
+    const fields = writableColumns.map((col) => {
+      const mappedName = fieldNameMapping[col.name] ?? col.name;
+      const tsType = mapSharePointTypeToTs(col.type);
+      return {
+        name: mappedName,
+        tsType,
+        required: col.required,
+        description: col.displayName !== col.name ? col.displayName : void 0
+      };
+    });
+    const interfaceName = sanitizeInterfaceName(input.outputType);
+    interfaces.push(generateInterface(interfaceName, fields));
+  }
+  return interfaces.join("\n\n") + "\n";
+}
+function isSystemColumn(name) {
+  const systemColumns = /* @__PURE__ */ new Set([
+    "ContentType",
+    "Modified",
+    "Created",
+    "Author",
+    "Editor",
+    "_ModerationComments",
+    "_ModerationStatus",
+    "FileSystemObjectType",
+    "ServerRedirectedEmbedUri",
+    "ServerRedirectedEmbedUrl",
+    "ID",
+    "ContentTypeId",
+    "Attachments",
+    "GUID",
+    "OData__UIVersionString",
+    "ComplianceAssetId"
+  ]);
+  return systemColumns.has(name);
+}
+
+// src/client/errors.ts
+var SpError = class extends Error {
+  constructor(message, status, code, requestId = "") {
+    super(message);
+    this.name = "SpError";
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code,
+      requestId: this.requestId
+    };
+  }
+};
+var SpAuthError = class extends SpError {
+  constructor(message, status = 401, requestId = "") {
+    super(message, status, "AuthenticationError", requestId);
+    this.name = "SpAuthError";
+  }
+};
+var SpNotFoundError = class extends SpError {
+  constructor(message, requestId = "") {
+    super(message, 404, "ItemNotFound", requestId);
+    this.name = "SpNotFoundError";
+  }
+};
+var SpThrottleError = class extends SpError {
+  constructor(message, retryAfter = 0, requestId = "") {
+    super(message, 429, "TooManyRequests", requestId);
+    this.name = "SpThrottleError";
+    this.retryAfter = retryAfter;
+  }
+};
+var SpValidationError = class extends SpError {
+  constructor(message, fieldErrors = {}, requestId = "") {
+    super(message, 400, "ValidationError", requestId);
+    this.name = "SpValidationError";
+    this.fieldErrors = fieldErrors;
+  }
+};
+function parseGraphError(status, body, retryAfterHeader) {
+  const { error } = body;
+  const requestId = error.innerError?.["request-id"] ?? "";
+  const message = error.message || "Unknown SharePoint error";
+  const code = error.code || "UnknownError";
+  if (status === 401 || status === 403) {
+    return new SpAuthError(message, status, requestId);
+  }
+  if (status === 404) {
+    return new SpNotFoundError(message, requestId);
+  }
+  if (status === 429) {
+    const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : 0;
+    return new SpThrottleError(message, retryAfter, requestId);
+  }
+  if (status === 400) {
+    return new SpValidationError(message, {}, requestId);
+  }
+  return new SpError(message, status, code, requestId);
+}
+
+// src/client/utils.ts
+var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+function buildGraphUrl(siteId, ...segments) {
+  const path = segments.filter(Boolean).join("/");
+  return `${GRAPH_BASE}/sites/${siteId}/${path}`;
+}
+function buildFilterQuery(contentTypeName, additionalFilter) {
+  const parts = [];
+  if (contentTypeName) {
+    parts.push(`fields/ContentType/Name eq '${contentTypeName}'`);
+  }
+  if (additionalFilter) {
+    parts.push(additionalFilter);
+  }
+  return parts.join(" and ");
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function calculateBackoff(attempt, baseDelay = 1e3, maxDelay = 3e4) {
+  const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+  const jitter = delay * 0.1 * Math.random();
+  return delay + jitter;
+}
+
+// src/client/sp-client.ts
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 3e4
+};
+function createSpClient(config) {
+  const { siteId, getAccessToken } = config;
+  const retryOpts = { ...DEFAULT_RETRY, ...config.retryOptions };
+  async function request(url, options = {}) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= retryOpts.maxRetries; attempt++) {
+      const token = await getAccessToken();
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+      if (response.ok) {
+        if (response.status === 204) {
+          return void 0;
+        }
+        return await response.json();
+      }
+      const body = await response.json().catch(() => ({
+        error: { code: "UnknownError", message: response.statusText }
+      }));
+      const error = parseGraphError(
+        response.status,
+        body,
+        response.headers.get("Retry-After")
+      );
+      if (error instanceof SpThrottleError && attempt < retryOpts.maxRetries) {
+        const waitTime = error.retryAfter ? error.retryAfter * 1e3 : calculateBackoff(attempt, retryOpts.baseDelay, retryOpts.maxDelay);
+        await sleep(waitTime);
+        lastError = error;
+        continue;
+      }
+      throw error;
+    }
+    throw lastError ?? new Error("Max retries exceeded");
+  }
+  return {
+    async getListItems(options) {
+      const { listId, contentTypeName, filter, select, expand, orderBy, top, skip } = options;
+      const params = new URLSearchParams();
+      const filterQuery = buildFilterQuery(contentTypeName, filter);
+      if (filterQuery) params.set("$filter", filterQuery);
+      if (select?.length) params.set("$select", select.join(","));
+      if (expand?.length) params.set("$expand", expand.join(","));
+      if (orderBy) params.set("$orderby", orderBy);
+      if (top) params.set("$top", String(top));
+      if (skip) params.set("$skip", String(skip));
+      const queryString = params.toString();
+      const url = buildGraphUrl(siteId, "lists", listId, "items") + (queryString ? `?expand=fields&${queryString}` : "?expand=fields");
+      const response = await request(url);
+      return response.value.map((item) => ({
+        id: item.id,
+        fields: item.fields,
+        contentType: item.fields.ContentType ? { id: "", name: item.fields.ContentType.Name } : void 0,
+        createdDateTime: item.createdDateTime,
+        lastModifiedDateTime: item.lastModifiedDateTime,
+        createdBy: item.createdBy,
+        lastModifiedBy: item.lastModifiedBy,
+        webUrl: item.webUrl
+      }));
+    },
+    async getItem(options) {
+      const { listId, itemId, select, expand } = options;
+      const params = new URLSearchParams();
+      if (select?.length) params.set("$select", select.join(","));
+      if (expand?.length) params.set("$expand", expand.join(","));
+      const queryString = params.toString();
+      const url = buildGraphUrl(siteId, "lists", listId, "items", itemId) + (queryString ? `?expand=fields&${queryString}` : "?expand=fields");
+      const item = await request(url);
+      return {
+        id: item.id,
+        fields: item.fields,
+        createdDateTime: item.createdDateTime,
+        lastModifiedDateTime: item.lastModifiedDateTime
+      };
+    },
+    async createItem(options) {
+      const { listId, fields, contentTypeId } = options;
+      const url = buildGraphUrl(siteId, "lists", listId, "items");
+      const body = { fields };
+      if (contentTypeId) {
+        body.fields["ContentType@odata.type"] = contentTypeId;
+      }
+      const item = await request(url, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      return { id: item.id, fields: item.fields };
+    },
+    async updateItem(options) {
+      const { listId, itemId, fields } = options;
+      const url = buildGraphUrl(siteId, "lists", listId, "items", itemId, "fields");
+      const updatedFields = await request(url, {
+        method: "PATCH",
+        body: JSON.stringify(fields)
+      });
+      return { id: itemId, fields: updatedFields };
+    },
+    async deleteItem(options) {
+      const { listId, itemId } = options;
+      const url = buildGraphUrl(siteId, "lists", listId, "items", itemId);
+      await request(url, { method: "DELETE" });
+    },
+    async getSites(options) {
+      const params = new URLSearchParams();
+      if (options?.search) params.set("search", options.search);
+      const queryString = params.toString();
+      const url = `https://graph.microsoft.com/v1.0/sites${queryString ? `?${queryString}` : ""}`;
+      const response = await request(url);
+      return response.value;
+    },
+    async getLists() {
+      const url = buildGraphUrl(siteId, "lists");
+      const response = await request(url);
+      return response.value;
+    },
+    async getList(options) {
+      const url = buildGraphUrl(siteId, "lists", options.listId);
+      return request(url);
+    },
+    async getContentTypes(options) {
+      const url = options?.listId ? buildGraphUrl(siteId, "lists", options.listId, "contentTypes") : buildGraphUrl(siteId, "contentTypes");
+      const response = await request(url);
+      return response.value;
+    },
+    async getListContentTypes(options) {
+      const url = buildGraphUrl(siteId, "lists", options.listId, "contentTypes");
+      const response = await request(url);
+      return response.value;
+    },
+    async getColumns(options) {
+      const url = buildGraphUrl(siteId, "contentTypes", options.contentTypeId, "columns");
+      const response = await request(url);
+      return response.value;
+    },
+    async getListColumns(options) {
+      const url = buildGraphUrl(siteId, "lists", options.listId, "columns");
+      const response = await request(url);
+      return response.value;
+    }
+  };
+}
+
+// src/cli/generate-types.ts
+async function generateTypes(options) {
+  const { configPath, nonInteractive = false, strategy, clearCache = false } = options;
+  console.log("\nSharePoint Kit - Type Generator\n");
+  const config = await loadConfig(configPath);
+  const outputDir = config.options?.outputDir ?? "./generated";
+  const outputFile = config.options?.outputFile ?? "sp-types.ts";
+  const cacheManager = new CacheManager(outputDir);
+  if (clearCache) {
+    cacheManager.clear();
+    console.log("Cache cleared.\n");
+    return;
+  }
+  const globalStrategy = strategy ?? config.defaultStrategy ?? "interactive";
+  console.log(`Site: ${config.siteId}`);
+  console.log(`Strategy: ${globalStrategy}`);
+  console.log(`Output: ${outputDir}/${outputFile}
+`);
+  const getAccessToken = await createTokenProvider(config);
+  const client = createSpClient({
+    siteId: config.siteId,
+    getAccessToken
+  });
+  console.log("Scanning SharePoint site...\n");
+  const allResolved = [];
+  for (const ctConfig of config.contentTypes) {
+    console.log(`Processing: "${ctConfig.contentTypeName}" -> ${ctConfig.outputType}`);
+    try {
+      const resolved = await resolveContentType(
+        ctConfig,
+        config.siteId,
+        client,
+        cacheManager,
+        globalStrategy,
+        nonInteractive
+      );
+      allResolved.push(...resolved);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`  Error: ${message}`);
+      if (nonInteractive) {
+        throw error;
+      }
+    }
+  }
+  if (allResolved.length === 0) {
+    console.log("\nNo content types resolved. Nothing to generate.\n");
+    return;
+  }
+  console.log(`
+Generating TypeScript interfaces...
+`);
+  const tsContent = await generateTypeScript(
+    allResolved,
+    client,
+    { fieldNameMapping: config.options?.fieldNameMapping }
+  );
+  const outputPath = resolve2(process.cwd(), outputDir, outputFile);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync2(outputPath, tsContent, "utf-8");
+  console.log(`
+Done! Generated ${allResolved.length} interface(s).`);
+  console.log(`Output: ${outputPath}
+`);
+}
+async function createTokenProvider(config) {
+  if (!config.tenantId || !config.clientId) {
+    throw new Error(
+      "tenantId and clientId are required in config for authentication. You can set them via environment variables: SHAREPOINT_TENANT_ID, SHAREPOINT_CLIENT_ID"
+    );
+  }
+  const clientSecret = config.clientSecret ?? process.env.SHAREPOINT_CLIENT_SECRET;
+  if (!clientSecret) {
+    throw new Error(
+      "clientSecret is required for authentication. Set it in config or via SHAREPOINT_CLIENT_SECRET environment variable"
+    );
+  }
+  const msalConfig = {
+    auth: {
+      clientId: config.clientId,
+      authority: `https://login.microsoftonline.com/${config.tenantId}`,
+      clientSecret
+    }
+  };
+  const cca = new ConfidentialClientApplication(msalConfig);
+  return async () => {
+    const result = await cca.acquireTokenByClientCredential({
+      scopes: ["https://graph.microsoft.com/.default"]
+    });
+    if (!result?.accessToken) {
+      throw new Error("Failed to acquire access token");
+    }
+    return result.accessToken;
+  };
+}
+
+// bin/sp-generate-types.ts
+var program = new Command();
+program.name("sp-generate-types").description("Generate TypeScript interfaces from SharePoint content types").version("0.1.0").requiredOption("-c, --config <path>", "Path to sharepoint.config.ts or .json file").option("--non-interactive", "Run in non-interactive mode (for CI/CD)", false).option(
+  "-s, --strategy <strategy>",
+  "List selection strategy when multiple lists found (interactive|first|error|all)"
+).option("--clear-cache", "Clear the resolution cache and exit", false).option("--update-cache", "Force update the cache", false).action(async (opts) => {
+  try {
+    await generateTypes({
+      configPath: opts.config,
+      nonInteractive: opts.nonInteractive,
+      strategy: opts.strategy,
+      clearCache: opts.clearCache,
+      updateCache: opts.updateCache
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`
+Error: ${message}
+`);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=sp-generate-types.js.map