@slamb2k/dvx 1.0.7

package/dist/chunk-QFYVVOAX.js

@@ -0,0 +1,1041 @@
+#!/usr/bin/env node
+
+// src/errors.ts
+var DvxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DvxError";
+  }
+};
+var AuthError = class extends DvxError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var AuthProfileNotFoundError = class extends AuthError {
+  constructor(profileName) {
+    super(`Auth profile '${profileName}' not found`);
+    this.name = "AuthProfileNotFoundError";
+  }
+};
+var AuthProfileExistsError = class extends AuthError {
+  constructor(profileName) {
+    super(`Auth profile '${profileName}' already exists`);
+    this.name = "AuthProfileExistsError";
+  }
+};
+var TokenAcquisitionError = class extends AuthError {
+  constructor(message) {
+    super(`Failed to acquire token: ${message}`);
+    this.name = "TokenAcquisitionError";
+  }
+};
+var DataverseError = class extends DvxError {
+  statusCode;
+  errorCode;
+  retryAfterSeconds;
+  constructor(message, statusCode, errorCode, retryAfterSeconds) {
+    super(message);
+    this.name = "DataverseError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+var EntityNotFoundError = class extends DataverseError {
+  constructor(entity) {
+    super(`Entity '${entity}' not found`, 404);
+    this.name = "EntityNotFoundError";
+  }
+};
+var RecordNotFoundError = class extends DataverseError {
+  constructor(entity, id) {
+    super(`Record '${id}' not found in '${entity}'`, 404);
+    this.name = "RecordNotFoundError";
+  }
+};
+var ValidationError = class extends DvxError {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var FetchXmlValidationError = class extends DvxError {
+  constructor(message) {
+    super(message);
+    this.name = "FetchXmlValidationError";
+  }
+};
+var ActionError = class extends DvxError {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ActionError";
+  }
+};
+var ImpersonationPrivilegeError = class extends DataverseError {
+  constructor(message = "Caller does not have the Act on Behalf of Another User privilege (prvActOnBehalfOfAnotherUser)") {
+    super(message, 403);
+    this.name = "ImpersonationPrivilegeError";
+  }
+};
+var PkceFlowError = class extends AuthError {
+  constructor(message) {
+    super(message);
+    this.name = "PkceFlowError";
+  }
+};
+
+// src/utils/cli.ts
+import * as clack from "@clack/prompts";
+var uxState = { quiet: false, noColor: false };
+function setUxOptions(opts) {
+  uxState = opts;
+}
+function isInteractive() {
+  return Boolean(process.stderr.isTTY) && !uxState.quiet;
+}
+function createSpinner() {
+  if (!isInteractive()) {
+    return { start() {
+    }, stop() {
+    }, message() {
+    }, error() {
+    } };
+  }
+  const s = clack.spinner();
+  return {
+    start(msg) {
+      s.start(msg);
+    },
+    stop(msg) {
+      s.stop(msg);
+    },
+    message(msg) {
+      s.message(msg);
+    },
+    error(msg) {
+      s.stop(msg);
+    }
+  };
+}
+function logSuccess(msg) {
+  if (isInteractive()) {
+    clack.log.success(msg);
+  } else {
+    process.stderr.write(`${msg}
+`);
+  }
+}
+function logError(msg) {
+  if (isInteractive()) {
+    clack.log.error(msg);
+  } else {
+    process.stderr.write(`Error: ${msg}
+`);
+  }
+}
+function logWarn(msg) {
+  if (!isInteractive()) return;
+  clack.log.warn(msg);
+}
+function logInfo(msg) {
+  if (isInteractive()) {
+    clack.log.info(msg);
+  } else {
+    process.stderr.write(`Hint: ${msg}
+`);
+  }
+}
+function logStep(msg) {
+  if (!isInteractive()) return;
+  clack.log.step(msg);
+}
+function logDryRun(method, url, body) {
+  if (isInteractive()) {
+    clack.log.warn(`[DRY RUN] ${method} ${url}`);
+    if (body !== void 0) {
+      clack.log.info(`Body: ${JSON.stringify(body)}`);
+    }
+  } else {
+    process.stderr.write(`[DRY RUN] ${method} ${url}
+`);
+    if (body !== void 0) {
+      process.stderr.write(`[DRY RUN] Body: ${JSON.stringify(body)}
+`);
+    }
+  }
+}
+function logMutationSuccess(msg) {
+  if (!isInteractive()) return;
+  clack.log.success(msg);
+}
+async function promptConfirmClack(msg) {
+  if (!isInteractive()) return false;
+  const result = await clack.confirm({ message: msg });
+  if (clack.isCancel(result)) return false;
+  return result;
+}
+async function promptUrl(msg, placeholder) {
+  const url = await clack.text({
+    message: msg,
+    placeholder: placeholder ?? "https://org.crm.dynamics.com",
+    validate: (value) => {
+      if (!value) return "Please enter a valid URL";
+      try {
+        new URL(value);
+      } catch {
+        return "Please enter a valid URL";
+      }
+    }
+  });
+  if (clack.isCancel(url)) {
+    clack.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return url;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// src/client/create-client.ts
+import * as path2 from "path";
+
+// src/auth/auth-manager.ts
+import * as fs from "fs";
+import * as path from "path";
+import { ConfidentialClientApplication, PublicClientApplication } from "@azure/msal-node";
+
+// src/auth/auth-profile.ts
+import { z } from "zod";
+var AuthProfileSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["service-principal", "delegated"]),
+  environmentUrl: z.string().url(),
+  tenantId: z.string().uuid(),
+  clientId: z.string().uuid(),
+  clientSecret: z.string().optional(),
+  homeAccountId: z.string().optional()
+});
+var AuthConfigSchema = z.object({
+  activeProfile: z.string().optional(),
+  profiles: z.record(z.string(), AuthProfileSchema)
+});
+
+// src/auth/msal-cache-plugin.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+var MsalCachePlugin = class {
+  constructor(cacheFilePath) {
+    this.cacheFilePath = cacheFilePath;
+  }
+  async beforeCacheAccess(ctx) {
+    try {
+      const data = readFileSync(this.cacheFilePath, "utf-8");
+      ctx.tokenCache.deserialize(data);
+    } catch {
+    }
+  }
+  async afterCacheAccess(ctx) {
+    if (ctx.cacheHasChanged) {
+      mkdirSync(dirname(this.cacheFilePath), { recursive: true });
+      writeFileSync(this.cacheFilePath, ctx.tokenCache.serialize(), { encoding: "utf-8", mode: 384 });
+    }
+  }
+};
+
+// src/utils/browser.ts
+import { execFile } from "child_process";
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  execFile(cmd, [url], (err) => {
+    if (err) {
+      console.error(`Failed to open browser: ${err.message}`);
+      console.error(`Please open this URL manually: ${url}`);
+    }
+  });
+}
+
+// src/auth/auth-manager.ts
+var CONFIG_DIR = ".dvx";
+var CONFIG_FILE = "config.json";
+var AuthManager = class {
+  configPath;
+  basePath;
+  config;
+  constructor(basePath) {
+    this.basePath = basePath ?? process.cwd();
+    this.configPath = path.join(this.basePath, CONFIG_DIR, CONFIG_FILE);
+    this.config = this.loadConfig();
+  }
+  loadConfig() {
+    try {
+      const raw = fs.readFileSync(this.configPath, "utf-8");
+      return AuthConfigSchema.parse(JSON.parse(raw));
+    } catch {
+      return { profiles: {} };
+    }
+  }
+  saveConfig() {
+    const dir = path.dirname(this.configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const safeConfig = {
+      activeProfile: this.config.activeProfile,
+      profiles: {}
+    };
+    for (const [name, profile] of Object.entries(this.config.profiles)) {
+      const { clientSecret: _secret, ...rest } = profile;
+      safeConfig.profiles[name] = rest;
+    }
+    fs.writeFileSync(this.configPath, JSON.stringify(safeConfig, null, 2));
+  }
+  createProfile(profile) {
+    if (this.config.profiles[profile.name]) {
+      throw new AuthProfileExistsError(profile.name);
+    }
+    this.config.profiles[profile.name] = profile;
+    if (!this.config.activeProfile) {
+      this.config.activeProfile = profile.name;
+    }
+    this.saveConfig();
+  }
+  getActiveProfile() {
+    const name = this.config.activeProfile;
+    if (!name || !this.config.profiles[name]) {
+      throw new AuthProfileNotFoundError(name ?? "default");
+    }
+    return this.config.profiles[name];
+  }
+  listProfiles() {
+    return Object.entries(this.config.profiles).map(([name, profile]) => ({
+      name,
+      active: name === this.config.activeProfile,
+      profile
+    }));
+  }
+  selectProfile(name) {
+    if (!this.config.profiles[name]) {
+      throw new AuthProfileNotFoundError(name);
+    }
+    this.config.activeProfile = name;
+    this.saveConfig();
+  }
+  deleteProfile(name) {
+    if (!this.config.profiles[name]) {
+      throw new AuthProfileNotFoundError(name);
+    }
+    delete this.config.profiles[name];
+    if (this.config.activeProfile === name) {
+      const remaining = Object.keys(this.config.profiles);
+      this.config.activeProfile = remaining.length > 0 ? remaining[0] : void 0;
+    }
+    this.saveConfig();
+  }
+  deleteAllProfiles() {
+    this.config.profiles = {};
+    this.config.activeProfile = void 0;
+    this.saveConfig();
+  }
+  saveProfile(profile) {
+    this.config.profiles[profile.name] = profile;
+    this.saveConfig();
+  }
+  async getTokenDelegated(profile) {
+    const cacheFilePath = path.join(this.basePath, ".dvx", "msal-cache.json");
+    const pca = new PublicClientApplication({
+      auth: {
+        clientId: profile.clientId,
+        authority: `https://login.microsoftonline.com/${profile.tenantId}`
+      },
+      cache: {
+        cachePlugin: new MsalCachePlugin(cacheFilePath)
+      }
+    });
+    const scopes = [`${profile.environmentUrl}/user_impersonation`];
+    const accounts = await pca.getAllAccounts();
+    if (accounts.length > 0 && accounts[0]) {
+      try {
+        const result2 = await pca.acquireTokenSilent({
+          account: accounts[0],
+          scopes
+        });
+        if (result2?.accessToken) return result2.accessToken;
+      } catch {
+      }
+    }
+    const result = await pca.acquireTokenInteractive({
+      scopes,
+      openBrowser: async (url) => {
+        openBrowser(url);
+      },
+      successTemplate: "<h1>Authentication complete. You may close this tab.</h1>",
+      errorTemplate: "<h1>Authentication failed: {error}</h1>"
+    });
+    if (!result?.accessToken) throw new PkceFlowError("No access token returned from interactive login");
+    if (result.account?.homeAccountId) {
+      profile.homeAccountId = result.account.homeAccountId;
+      this.saveProfile(profile);
+    }
+    return result.accessToken;
+  }
+  async getToken(profileOrName) {
+    let p;
+    if (typeof profileOrName === "string") {
+      if (!this.config.profiles[profileOrName]) {
+        throw new AuthProfileNotFoundError(profileOrName);
+      }
+      p = this.config.profiles[profileOrName];
+    } else {
+      p = profileOrName ?? this.getActiveProfile();
+    }
+    if (p.type === "delegated") {
+      return this.getTokenDelegated(p);
+    }
+    const clientSecret = p.clientSecret ?? process.env["DATAVERSE_CLIENT_SECRET"];
+    if (!clientSecret) {
+      throw new TokenAcquisitionError(
+        "Client secret not found. Set DATAVERSE_CLIENT_SECRET environment variable."
+      );
+    }
+    const app = new ConfidentialClientApplication({
+      auth: {
+        clientId: p.clientId,
+        clientSecret,
+        authority: `https://login.microsoftonline.com/${p.tenantId}`
+      }
+    });
+    const result = await app.acquireTokenByClientCredential({
+      scopes: [`${p.environmentUrl}/.default`]
+    });
+    if (!result?.accessToken) {
+      throw new TokenAcquisitionError("No access token returned from Entra ID");
+    }
+    return result.accessToken;
+  }
+};
+
+// src/client/dataverse-client.ts
+import { z as z2 } from "zod";
+
+// src/schema/schema-cache.ts
+var DEFAULT_TTL_MS = 3e5;
+var SchemaCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs ?? (Number(process.env["DVX_SCHEMA_CACHE_TTL_MS"]) || DEFAULT_TTL_MS);
+  }
+  get(entityName) {
+    const entry = this.cache.get(entityName.toLowerCase());
+    if (!entry) return void 0;
+    const age = Date.now() - entry.cachedAt.getTime();
+    if (age > entry.ttlMs) {
+      this.cache.delete(entityName.toLowerCase());
+      return void 0;
+    }
+    return entry;
+  }
+  set(entry) {
+    this.cache.set(entry.logicalName.toLowerCase(), {
+      ...entry,
+      cachedAt: /* @__PURE__ */ new Date(),
+      ttlMs: this.ttlMs
+    });
+  }
+  invalidate(entityName) {
+    this.cache.delete(entityName.toLowerCase());
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// src/utils/retry.ts
+var DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4
+};
+async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === opts.maxRetries) break;
+      if (error instanceof DataverseError) {
+        if (error.statusCode === 429 || error.statusCode >= 500) {
+          const delay = error.retryAfterSeconds ? Math.min(error.retryAfterSeconds * 1e3, opts.maxDelayMs) : Math.min(opts.baseDelayMs * Math.pow(2, attempt), opts.maxDelayMs);
+          opts.onRetry?.(attempt + 1, delay, error);
+          await sleep(delay);
+          continue;
+        }
+      }
+      throw error;
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/validation.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ENTITY_NAME_REGEX = /^[a-z][a-z0-9_]*$/i;
+var DANGEROUS_CHARS = /[?#%]/;
+function validateGuid(value, label = "ID") {
+  if (!UUID_REGEX.test(value)) {
+    throw new ValidationError(`Invalid GUID for ${label}: '${value}'`);
+  }
+  return value.toLowerCase();
+}
+function validateEntityName(name) {
+  if (DANGEROUS_CHARS.test(name)) {
+    throw new ValidationError(`Entity name contains invalid characters: '${name}'`);
+  }
+  if (!ENTITY_NAME_REGEX.test(name)) {
+    throw new ValidationError(`Invalid entity logical name: '${name}'`);
+  }
+  return name.toLowerCase();
+}
+function validateActionName(name) {
+  if (!/^[A-Z][A-Za-z0-9_]*$/.test(name)) {
+    throw new ValidationError(
+      `Invalid action name "${name}": must start with uppercase letter and contain only letters, digits, or underscores`
+    );
+  }
+  return name;
+}
+function validateUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:") {
+      throw new ValidationError(`Environment URL must use HTTPS: '${url}'`);
+    }
+    return parsed.origin;
+  } catch (e) {
+    if (e instanceof ValidationError) throw e;
+    throw new ValidationError(`Invalid URL: '${url}'`);
+  }
+}
+
+// src/utils/fetchxml.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({ ignoreAttributes: false });
+function validateFetchXml(xml) {
+  let parsed;
+  try {
+    parsed = parser.parse(xml);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    throw new FetchXmlValidationError(`Invalid FetchXML: ${message}`);
+  }
+  if (!parsed["fetch"]) {
+    throw new FetchXmlValidationError("Invalid FetchXML: root element must be <fetch>");
+  }
+}
+function injectPagingCookie(xml, cookie, page) {
+  const decoded = decodeURIComponent(cookie);
+  const cleaned = xml.replace(/<fetch([^>]*)>/, (_match, attrs) => {
+    const stripped = attrs.replace(/\s+paging-cookie="[^"]*"/g, "").replace(/\s+page="[^"]*"/g, "");
+    return `<fetch${stripped}>`;
+  });
+  return cleaned.replace(
+    /<fetch/,
+    `<fetch paging-cookie="${decoded.replace(/"/g, "&quot;")}" page="${page}"`
+  );
+}
+
+// src/client/dataverse-client.ts
+var ODataResponseSchema = z2.object({
+  value: z2.array(z2.record(z2.string(), z2.unknown())),
+  "@odata.nextLink": z2.string().optional(),
+  "@odata.count": z2.number().optional()
+});
+var EntityDefinitionSchema = z2.object({
+  LogicalName: z2.string(),
+  DisplayName: z2.object({
+    UserLocalizedLabel: z2.object({ Label: z2.string() }).nullable().optional()
+  }),
+  EntitySetName: z2.string(),
+  PrimaryIdAttribute: z2.string(),
+  PrimaryNameAttribute: z2.string().nullable()
+});
+var EntityListResponseSchema = z2.object({
+  value: z2.array(EntityDefinitionSchema)
+});
+var SingleEntityDefinitionSchema = EntityDefinitionSchema.extend({
+  Attributes: z2.array(z2.object({
+    LogicalName: z2.string(),
+    DisplayName: z2.object({
+      UserLocalizedLabel: z2.object({ Label: z2.string() }).nullable().optional()
+    }),
+    AttributeType: z2.string(),
+    RequiredLevel: z2.object({ Value: z2.string() }),
+    IsCustomAttribute: z2.boolean(),
+    MaxLength: z2.number().optional(),
+    Targets: z2.array(z2.string()).optional()
+  }))
+});
+var DataverseClient = class {
+  authManager;
+  schemaCache;
+  baseUrl;
+  debug;
+  dryRun;
+  callerObjectId;
+  constructor(authManager, schemaCache, opts) {
+    this.authManager = authManager;
+    this.schemaCache = schemaCache ?? new SchemaCache();
+    this.debug = process.env["DVX_DEBUG"] === "true";
+    this.dryRun = opts?.dryRun ?? false;
+    this.callerObjectId = opts?.callerObjectId;
+  }
+  async getBaseUrl() {
+    if (this.baseUrl) return this.baseUrl;
+    const profile = this.authManager.getActiveProfile();
+    this.baseUrl = `${profile.environmentUrl}/api/data/v9.2`;
+    return this.baseUrl;
+  }
+  async request(url, options = {}) {
+    const token = await this.authManager.getToken();
+    const method = options.method ?? "GET";
+    const headers = {
+      "Authorization": `Bearer ${token}`,
+      "Accept": "application/json",
+      "OData-MaxVersion": "4.0",
+      "OData-Version": "4.0",
+      ...options.headers ?? {}
+    };
+    if (this.callerObjectId) {
+      headers["CallerObjectId"] = this.callerObjectId;
+    }
+    if (this.debug) {
+      console.error(`[DVX] ${method} ${url}`);
+    }
+    const response = await fetch(url, { ...options, headers });
+    if (!response.ok) {
+      let errorMessage = response.statusText;
+      let errorCode;
+      try {
+        const body = await response.json();
+        if (body.error) {
+          errorMessage = body.error.message ?? errorMessage;
+          errorCode = body.error.code;
+        }
+      } catch {
+      }
+      let retryAfterSeconds;
+      const retryAfterHeader = response.headers.get("Retry-After");
+      if (retryAfterHeader) {
+        const parsed = Number(retryAfterHeader);
+        if (!Number.isNaN(parsed) && parsed > 0) {
+          retryAfterSeconds = parsed;
+        }
+      }
+      if (response.status === 403 && this.callerObjectId && errorMessage.includes("prvActOnBehalfOfAnotherUser")) {
+        throw new ImpersonationPrivilegeError(errorMessage);
+      }
+      throw new DataverseError(errorMessage, response.status, errorCode, retryAfterSeconds);
+    }
+    return response;
+  }
+  async listEntities() {
+    const baseUrl = await this.getBaseUrl();
+    const url = `${baseUrl}/EntityDefinitions?$select=LogicalName,DisplayName,EntitySetName,PrimaryIdAttribute,PrimaryNameAttribute`;
+    const response = await withRetry(() => this.request(url));
+    const json = await response.json();
+    const parsed = EntityListResponseSchema.parse(json);
+    return parsed.value.map((e) => ({
+      logicalName: e.LogicalName,
+      displayName: e.DisplayName.UserLocalizedLabel?.Label ?? e.LogicalName,
+      entitySetName: e.EntitySetName
+    }));
+  }
+  async getEntitySchema(entityName, noCache = false) {
+    const name = validateEntityName(entityName);
+    if (!noCache) {
+      const cached = this.schemaCache.get(name);
+      if (cached) return cached;
+    }
+    const baseUrl = await this.getBaseUrl();
+    const url = `${baseUrl}/EntityDefinitions(LogicalName='${name}')?$expand=Attributes`;
+    const response = await withRetry(() => this.request(url));
+    const json = await response.json();
+    let parsed;
+    try {
+      parsed = SingleEntityDefinitionSchema.parse(json);
+    } catch {
+      throw new EntityNotFoundError(name);
+    }
+    const entry = {
+      logicalName: parsed.LogicalName,
+      displayName: parsed.DisplayName.UserLocalizedLabel?.Label ?? parsed.LogicalName,
+      entitySetName: parsed.EntitySetName,
+      primaryIdAttribute: parsed.PrimaryIdAttribute,
+      primaryNameAttribute: parsed.PrimaryNameAttribute ?? "",
+      attributes: parsed.Attributes.map((a) => ({
+        logicalName: a.LogicalName,
+        displayName: a.DisplayName.UserLocalizedLabel?.Label ?? a.LogicalName,
+        attributeType: a.AttributeType,
+        requiredLevel: a.RequiredLevel.Value,
+        isCustomAttribute: a.IsCustomAttribute,
+        maxLength: a.MaxLength,
+        targets: a.Targets
+      })),
+      cachedAt: /* @__PURE__ */ new Date(),
+      ttlMs: 0
+      // will be set by cache
+    };
+    this.schemaCache.set(entry);
+    return entry;
+  }
+  async query(entitySetName, odata, options = {}) {
+    const baseUrl = await this.getBaseUrl();
+    const maxRows = options.maxRows ?? (Number(process.env["DVX_MAX_ROWS"]) || 5e3);
+    let totalRecords = 0;
+    const records = [];
+    let url = `${baseUrl}/${entitySetName}?${odata}`;
+    if (options.fields?.length) {
+      const separator = odata.includes("$select") ? "" : `&$select=${options.fields.join(",")}`;
+      if (separator) url += separator;
+    }
+    let pageNumber = 0;
+    do {
+      const retryOpts = options.onRetry ? { onRetry: options.onRetry } : {};
+      const response = await withRetry(() => this.request(url), retryOpts);
+      const json = await response.json();
+      const parsed = ODataResponseSchema.parse(json);
+      for (const record of parsed.value) {
+        if (totalRecords >= maxRows) break;
+        totalRecords++;
+        if (options.onRecord) {
+          options.onRecord(record);
+        } else {
+          records.push(record);
+        }
+      }
+      pageNumber++;
+      options.onProgress?.({ recordCount: totalRecords, pageNumber });
+      if (totalRecords >= maxRows) break;
+      url = parsed["@odata.nextLink"] ?? "";
+    } while (url && options.pageAll);
+    return records;
+  }
+  async getRecord(entityName, id, fields) {
+    const name = validateEntityName(entityName);
+    const guid = validateGuid(id);
+    const schema = await this.getEntitySchema(name);
+    const baseUrl = await this.getBaseUrl();
+    let url = `${baseUrl}/${schema.entitySetName}(${guid})`;
+    if (fields?.length) {
+      url += `?$select=${fields.join(",")}`;
+    }
+    let response;
+    try {
+      response = await withRetry(() => this.request(url));
+    } catch (e) {
+      if (e instanceof DataverseError && e.statusCode === 404) {
+        throw new RecordNotFoundError(name, guid);
+      }
+      throw e;
+    }
+    const json = await response.json();
+    return json;
+  }
+  async createRecord(entityName, data) {
+    const name = validateEntityName(entityName);
+    const schema = await this.getEntitySchema(name);
+    const baseUrl = await this.getBaseUrl();
+    const url = `${baseUrl}/${schema.entitySetName}`;
+    if (this.dryRun) {
+      logDryRun("POST", url, data);
+      return "dry-run";
+    }
+    const response = await withRetry(() => this.request(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    }));
+    const entityIdHeader = response.headers.get("OData-EntityId") ?? "";
+    const match = /\(([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\)/i.exec(entityIdHeader);
+    if (!match?.[1]) {
+      throw new DataverseError("Create succeeded but OData-EntityId header missing", 201);
+    }
+    return match[1];
+  }
+  async updateRecord(entityName, id, data) {
+    const name = validateEntityName(entityName);
+    const guid = validateGuid(id);
+    const schema = await this.getEntitySchema(name);
+    const baseUrl = await this.getBaseUrl();
+    const url = `${baseUrl}/${schema.entitySetName}(${guid})`;
+    if (this.dryRun) {
+      logDryRun("PATCH", url, data);
+      return;
+    }
+    await withRetry(() => this.request(url, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data)
+    }));
+  }
+  async deleteRecord(entityName, id) {
+    const name = validateEntityName(entityName);
+    const guid = validateGuid(id);
+    const schema = await this.getEntitySchema(name);
+    const baseUrl = await this.getBaseUrl();
+    const url = `${baseUrl}/${schema.entitySetName}(${guid})`;
+    if (this.dryRun) {
+      logDryRun("DELETE", url);
+      return;
+    }
+    await withRetry(() => this.request(url, { method: "DELETE" }));
+  }
+  async queryFetchXml(entityName, fetchXml, onRecord, options) {
+    const name = validateEntityName(entityName);
+    const schema = await this.getEntitySchema(name);
+    const baseUrl = await this.getBaseUrl();
+    const maxRows = Number(process.env["DVX_MAX_ROWS"]) || 5e3;
+    let totalRecords = 0;
+    const records = [];
+    let page = 1;
+    let currentXml = fetchXml;
+    do {
+      const encoded = encodeURIComponent(currentXml);
+      const url = `${baseUrl}/${schema.entitySetName}?fetchXml=${encoded}`;
+      const fetchRetryOpts = options?.onRetry ? { onRetry: options.onRetry } : {};
+      const response = await withRetry(() => this.request(url), fetchRetryOpts);
+      const json = await response.json();
+      const parsed = ODataResponseSchema.parse(json);
+      for (const record of parsed.value) {
+        if (totalRecords >= maxRows) break;
+        totalRecords++;
+        if (onRecord) {
+          onRecord(record);
+        } else {
+          records.push(record);
+        }
+      }
+      options?.onProgress?.({ recordCount: totalRecords, pageNumber: page });
+      if (totalRecords >= maxRows) break;
+      const cookie = json["@Microsoft.Dynamics.CRM.fetchxmlpagingcookie"];
+      if (!cookie) break;
+      page++;
+      currentXml = injectPagingCookie(currentXml, cookie, page);
+    } while (true);
+    return records;
+  }
+  async executeAction(actionName, payload, opts) {
+    validateActionName(actionName);
+    const baseUrl = await this.getBaseUrl();
+    let url;
+    if (opts?.entityName && opts?.id) {
+      const guid = validateGuid(opts.id);
+      const schema = await this.getEntitySchema(opts.entityName);
+      url = `${baseUrl}/${schema.entitySetName}(${guid})/Microsoft.Dynamics.CRM.${actionName}`;
+    } else {
+      url = `${baseUrl}/${actionName}`;
+    }
+    if (this.dryRun) {
+      logDryRun("POST", url, payload);
+      return null;
+    }
+    try {
+      return await withRetry(async () => {
+        const response = await this.request(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        });
+        if (response.status === 204) return null;
+        const data = await response.json();
+        return z2.record(z2.string(), z2.unknown()).parse(data);
+      });
+    } catch (err) {
+      if (err instanceof DataverseError) {
+        throw new ActionError(err.message, err.statusCode);
+      }
+      throw err;
+    }
+  }
+  invalidateSchema(entityName) {
+    this.schemaCache.invalidate(entityName);
+  }
+  clearSchemaCache() {
+    this.schemaCache.clear();
+  }
+  async executeBatch(body, boundary) {
+    const baseUrl = await this.getBaseUrl();
+    const url = `${baseUrl}/$batch`;
+    if (this.dryRun) {
+      logDryRun("POST", url, { batchBodyLength: body.length });
+      return "";
+    }
+    const response = await withRetry(() => this.request(url, {
+      method: "POST",
+      headers: { "Content-Type": `multipart/mixed;boundary=${boundary}` },
+      body
+    }));
+    return await response.text();
+  }
+};
+
+// src/schema/sqlite-schema-cache.ts
+import Database from "better-sqlite3";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
+var SqliteSchemaCache = class {
+  db;
+  ttlMs;
+  constructor(dbPath, ttlMs = 3e5) {
+    mkdirSync3(dirname3(dbPath), { recursive: true });
+    this.db = new Database(dbPath);
+    this.ttlMs = ttlMs;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_cache (
+        logical_name TEXT PRIMARY KEY,
+        data TEXT NOT NULL,
+        cached_at INTEGER NOT NULL,
+        ttl_ms INTEGER NOT NULL
+      )
+    `);
+  }
+  get(entityName) {
+    const row = this.db.prepare(
+      "SELECT data, cached_at, ttl_ms FROM schema_cache WHERE logical_name = ?"
+    ).get(entityName.toLowerCase());
+    if (!row) return void 0;
+    if (Date.now() - row.cached_at >= row.ttl_ms) {
+      this.db.prepare("DELETE FROM schema_cache WHERE logical_name = ?").run(entityName.toLowerCase());
+      return void 0;
+    }
+    const entry = JSON.parse(row.data);
+    entry.cachedAt = new Date(entry.cachedAt);
+    return entry;
+  }
+  set(entry) {
+    this.db.prepare(
+      "INSERT OR REPLACE INTO schema_cache (logical_name, data, cached_at, ttl_ms) VALUES (?, ?, ?, ?)"
+    ).run(entry.logicalName.toLowerCase(), JSON.stringify(entry), Date.now(), this.ttlMs);
+  }
+  invalidate(entityName) {
+    this.db.prepare("DELETE FROM schema_cache WHERE logical_name = ?").run(entityName.toLowerCase());
+  }
+  clear() {
+    this.db.prepare("DELETE FROM schema_cache").run();
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/client/create-client.ts
+async function createClient(opts) {
+  const authManager = new AuthManager();
+  const dbPath = process.env["DVX_SCHEMA_CACHE_PATH"] ?? path2.join(process.cwd(), ".dvx", "cache.db");
+  const ttlMs = Number(process.env["DVX_SCHEMA_CACHE_TTL_MS"]) || 3e5;
+  const schemaCache = new SqliteSchemaCache(dbPath, ttlMs);
+  const client = new DataverseClient(authManager, schemaCache, opts);
+  return { authManager, client };
+}
+
+// src/utils/batch-builder.ts
+function chunkArray(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+function serializeOperation(op, boundary, autoContentId) {
+  const parts = [];
+  parts.push(`--${boundary}`);
+  parts.push("Content-Type: application/http");
+  parts.push("Content-Transfer-Encoding: binary");
+  const contentId = op.contentId ?? autoContentId;
+  if (contentId) {
+    parts.push(`Content-ID: ${contentId}`);
+  }
+  parts.push("");
+  parts.push(`${op.method} ${op.path} HTTP/1.1`);
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json",
+    ...op.headers ?? {}
+  };
+  const serializedBody = op.body !== void 0 ? JSON.stringify(op.body) : void 0;
+  if (serializedBody !== void 0) {
+    headers["Content-Length"] = String(Buffer.byteLength(serializedBody, "utf-8"));
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    parts.push(`${key}: ${value}`);
+  }
+  parts.push("");
+  if (serializedBody !== void 0) {
+    parts.push(serializedBody);
+  }
+  parts.push("");
+  return parts;
+}
+function buildBatchBody(operations, batchBoundary, options) {
+  const parts = [];
+  const changesetSize = options?.changesetSize ?? 100;
+  if (options?.atomic) {
+    const chunks = chunkArray(operations, changesetSize);
+    for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+      const chunk = chunks[chunkIndex];
+      const changesetBoundary = `changeset_${batchBoundary}_${chunkIndex}`;
+      parts.push(`--${batchBoundary}`);
+      parts.push(`Content-Type: multipart/mixed;boundary=${changesetBoundary}`);
+      parts.push("");
+      for (let opIndex = 0; opIndex < chunk.length; opIndex++) {
+        const op = chunk[opIndex];
+        parts.push(...serializeOperation(op, changesetBoundary, String(chunkIndex * changesetSize + opIndex + 1)));
+      }
+      parts.push(`--${changesetBoundary}--`);
+    }
+  } else {
+    for (const op of operations) {
+      parts.push(...serializeOperation(op, batchBoundary));
+    }
+  }
+  parts.push(`--${batchBoundary}--`);
+  return parts.join("\r\n");
+}
+
+export {
+  DataverseError,
+  EntityNotFoundError,
+  ValidationError,
+  ImpersonationPrivilegeError,
+  MsalCachePlugin,
+  openBrowser,
+  AuthManager,
+  validateGuid,
+  validateEntityName,
+  validateUrl,
+  validateFetchXml,
+  setUxOptions,
+  isInteractive,
+  createSpinner,
+  logSuccess,
+  logError,
+  logWarn,
+  logInfo,
+  logStep,
+  logMutationSuccess,
+  promptConfirmClack,
+  promptUrl,
+  stripAnsi,
+  createClient,
+  chunkArray,
+  buildBatchBody
+};
+//# sourceMappingURL=chunk-QFYVVOAX.js.map