import { DataverseClient } from "@mohsinonxrm/dataverse-sdk-core";
import { MsalNodeTokenProvider } from "@mohsinonxrm/dataverse-sdk-auth-msal-node";
import { ConfidentialClientApplication } from "@azure/msal-node";

// Configure MSAL
const cca = new ConfidentialClientApplication({
  auth: {
    clientId: process.env.AZURE_CLIENT_ID!,
    authority: `https://login.microsoftonline.com/${process.env.AZURE_TENANT_ID}`,
    clientSecret: process.env.AZURE_CLIENT_SECRET!,
  },
});

// Create token provider
const tokenProvider = new MsalNodeTokenProvider(cca, {
  flow: "clientCredentials",
  scopes: ["https://yourorg.crm.dynamics.com/.default"],
});

// Create Dataverse client
const client = new DataverseClient({
  baseUrl: "https://yourorg.crm.dynamics.com",
  tokenProvider,
});

// Query data
const accounts = await client
  .api("/accounts")
  .select("name", "revenue")
  .filter("revenue gt 1000000")
  .orderBy("revenue desc")
  .top(10)
  .get();

console.log(accounts);

import { DataverseClient } from '@mohsinonxrm/dataverse-sdk-core';
import { MsalBrowserTokenProvider } from '@mohsinonxrm/dataverse-sdk-auth-msal-browser';
import { PublicClientApplication } from '@azure/msal-browser';

// Configure MSAL
const msalInstance = new PublicClientApplication({
  auth: {
    clientId: 'your-app-registration-id',
    authority: 'https://login.microsoftonline.com/your-tenant-id',
    redirectUri: window.location.origin,
  },
});

// Create token provider
const tokenProvider = new MsalBrowserTokenProvider(msalInstance, {
  scopes: ['https://yourorg.crm.dynamics.com/user_impersonation'],
});

// Create client
const client = new DataverseClient({
  baseUrl: 'https://yourorg.crm.dynamics.com',
  tokenProvider,
});

// Use in React component
function AccountList() {
  const [accounts, setAccounts] = useState([]);

  useEffect(() => {
    client.api('/accounts')
      .select('name', 'revenue')
      .top(50)
      .get()
      .then(setAccounts);
  }, []);

  return <div>{/* Render accounts */}</div>;
}

// OData query building
const highValueAccounts = await client
  .api("/accounts")
  .select("name", "revenue", "industrycode")
  .filter("revenue gt 5000000 and industrycode eq 6")
  .expand("primarycontactid($select=fullname,emailaddress1)")
  .orderBy("revenue desc")
  .top(25)
  .get<Account[]>();

// Create with return
const newAccount = await client
  .api("/accounts")
  .header("Prefer", "return=representation")
  .post<Account>({
    name: "Contoso Ltd",
    revenue: 10000000,
    industrycode: 6,
  });

// Update with optimistic concurrency
await client.api(`/accounts(${accountId})`).ifMatch(etag).patch({
  revenue: 12000000,
});

// Paging support
for await (const account of client.api("/accounts").select("name").iterate()) {
  console.log(account.name);
}

import { OrganizationService } from "@mohsinonxrm/dataverse-sdk-xrm";

const org = new OrganizationService(client);

// Create
const accountId = await org.create("accounts", {
  name: "Fabrikam Inc",
  revenue: 5000000,
});

// Retrieve
const account = await org.retrieve("accounts", accountId, {
  select: ["name", "revenue"],
  expand: {
    primarycontactid: { select: ["fullname"] },
  },
});

// Update
await org.update(
  "accounts",
  accountId,
  {
    websiteurl: "https://fabrikam.com",
  },
  { etag: account["@odata.etag"] }
);

// Delete
await org.delete("accounts", accountId);

// Associate
await org.associate("accounts", accountId, "contact_customer_accounts", [contactId1, contactId2]);

import { CreateMultipleAction, WinOpportunityAction } from "@mohsinonxrm/dataverse-sdk-actions";

// Bulk create
const createMultiple = new CreateMultipleAction("accounts", [
  { "@odata.type": "Microsoft.Dynamics.CRM.account", name: "Account 1" },
  { "@odata.type": "Microsoft.Dynamics.CRM.account", name: "Account 2" },
]);

const result = await client.execute(createMultiple);
console.log(result.Ids); // ['guid1', 'guid2']

// Win opportunity
const winAction = new WinOpportunityAction(
  {
    opportunityid: opportunityId,
    "opportunityid@odata.bind": `/opportunities(${opportunityId})`,
    actualrevenue: 100000,
    actualend: new Date(),
  },
  3
); // Status: Won

await client.execute(winAction);

import { WhoAmIFunction } from "@mohsinonxrm/dataverse-sdk-functions";

const whoAmI = await client.execute(new WhoAmIFunction());
console.log(whoAmI.UserId);

import { BatchRequestBuilder } from "@mohsinonxrm/dataverse-sdk-batch";

const batch = new BatchRequestBuilder(client);

// Non-transactional requests
batch.addRequest("get-accounts", "GET", "/accounts?$top=5");

// Transactional change set
batch.beginChangeset();

// Create account with Content-ID $1
batch.addRequest(
  "create-account",
  "POST",
  "/accounts",
  { "Content-Type": "application/json", Prefer: "return=representation" },
  { name: "Parent Account" }
);

// Create contact referencing $1
batch.addRequest(
  "create-contact",
  "POST",
  "/contacts",
  { "Content-Type": "application/json" },
  {
    firstname: "John",
    lastname: "Doe",
    "parentcustomerid_account@odata.bind": "$1", // References Content-ID
  }
);

batch.endChangeset();

// Execute
const result = await batch.execute();

if (result.success) {
  console.log("All operations succeeded");
} else {
  for (const [id, error] of result.errors) {
    console.error(`Request ${id} failed:`, error);
  }
}

import {
  WhoAmIRequest,
  ExecuteWorkflowRequest,
  MergeRequest,
  WinOpportunityRequest,
} from "@mohsinonxrm/dataverse-sdk-messages";
import { OrganizationService } from "@mohsinonxrm/dataverse-sdk-xrm";

const org = new OrganizationService(client);

// Platform messages (1,356+ available)
const whoAmI = await org.execute(new WhoAmIRequest());
console.log("User ID:", whoAmI.result.UserId);

// Execute workflow
const workflowRequest = new ExecuteWorkflowRequest(
  workflowId,
  recordId,
  {} // Input arguments
);
const workflowResponse = await org.execute(workflowRequest);

// Merge records
const mergeRequest = new MergeRequest(
  { logicalName: "account", id: targetAccountId },
  { logicalName: "account", id: subordinateAccountId },
  { name: "Merged Account Name" },
  false // PerformParentingChecks
);
await org.execute(mergeRequest);

import { MetadataClient, StringAttributeMetadataCreate } from "@mohsinonxrm/dataverse-sdk-metadata";

const metadata = new MetadataClient(client);

// Create custom entity
await metadata.createEntity({
  "@odata.type": "Microsoft.Dynamics.CRM.EntityMetadata",
  SchemaName: "new_CustomEntity",
  DisplayName: {
    LocalizedLabels: [{ Label: "Custom Entity", LanguageCode: 1033 }],
  },
  PrimaryNameAttribute: "new_name",
  Attributes: [
    /* ... */
  ],
});

// Create string attribute
const attribute: StringAttributeMetadataCreate = {
  "@odata.type": "Microsoft.Dynamics.CRM.StringAttributeMetadata",
  SchemaName: "new_Description",
  MaxLength: 500,
  DisplayName: {
    LocalizedLabels: [{ Label: "Description", LanguageCode: 1033 }],
  },
};

await metadata.createAttribute("new_custentity", attribute);

import { FileColumnClient } from "@mohsinonxrm/dataverse-sdk-files";

const fileClient = new FileColumnClient(client);

// Upload with progress
await fileClient.upload(
  "accounts",
  accountId,
  "new_logo",
  logoFile, // Blob or Buffer
  {
    chunkSize: 4 * 1024 * 1024, // 4MB chunks
    onProgress: (uploaded, total) => {
      console.log(`Upload: ${Math.round((uploaded / total) * 100)}%`);
    },
  }
);

// Download
const file = await fileClient.download("accounts", accountId, "new_logo");

import { Middleware } from "@mohsinonxrm/dataverse-sdk-core";

const customMiddleware: Middleware = {
  name: "CustomMiddleware",
  async execute(request, next) {
    console.log(`Request: ${request.method} ${request.url}`);
    const response = await next(request);
    console.log(`Response: ${response.status}`);
    return response;
  },
};

const client = new DataverseClient({
  baseUrl: "https://yourorg.crm.dynamics.com",
  tokenProvider,
  middleware: [customMiddleware],
});

import { ApplicationInsightsTelemetryClient } from "@mohsinonxrm/dataverse-sdk-appinsights";
import { ApplicationInsights } from "@azure/monitor-opentelemetry";

const appInsights = new ApplicationInsights({
  connectionString: process.env.APPLICATIONINSIGHTS_CONNECTION_STRING,
});

const client = new DataverseClient({
  baseUrl: "https://yourorg.crm.dynamics.com",
  tokenProvider,
  telemetryClient: new ApplicationInsightsTelemetryClient(appInsights),
});

import { OpenTelemetryClient } from "@mohsinonxrm/dataverse-sdk-otel";
import { trace } from "@opentelemetry/api";

const tracer = trace.getTracer("dataverse-sdk");

const client = new DataverseClient({
  baseUrl: "https://yourorg.crm.dynamics.com",
  tokenProvider,
  telemetryClient: new OpenTelemetryClient(tracer),
});

import { Account } from "./generated/entities/Account";
import { Contact } from "./generated/entities/Contact";

// Type-safe entity creation
const account = new Account();
account.name = "Contoso Ltd";
account.revenue = 5000000;

const id = await account.save(client);