@khester/create-dynamics-app 2.6.2 → 2.6.4

package/templates/react-custom-page/src/core/services/FetchApiService.ts

@@ -1,117 +0,0 @@
-import { IApiService } from "./IApiService";
-import { logCrud } from "./crudLogging";
-import { logger } from "@khester/reusable-components";
-
-/**
- * Dev API service for token-proxy mode (`npm run dev` with DYNAMICS_URL set).
- * Requests go to the SAME-ORIGIN path /api/data/v9.2/... and the Vite dev proxy
- * (vite.config.ts) injects the `Authorization: Bearer` header server-side — the
- * token is never read by, or bundled into, the client.
- */
-export class FetchApiService implements IApiService {
-  constructor(private baseUrl = "") {}
-
-  private headers(): HeadersInit {
-    return {
-      "Content-Type": "application/json; charset=utf-8",
-      Accept: "application/json",
-      "OData-Version": "4.0",
-      "OData-MaxVersion": "4.0",
-      Prefer: 'odata.include-annotations="*"',
-    };
-  }
-
-  retrieveMultipleRecords(
-    entity: string,
-    fetchXml: string,
-  ): Promise<{ entities: any[] }> {
-    return logCrud(
-      { op: "READ", entity, resultCount: (r) => r?.entities?.length },
-      async () => {
-        const url = `${this.baseUrl}/api/data/v9.2/${entity}?fetchXml=${encodeURIComponent(fetchXml)}`;
-        const response = await fetch(url, { method: "GET", headers: this.headers() });
-        if (!response.ok) {
-          const body = await response.text().catch(() => "");
-          throw new Error(`API error ${response.status}: ${response.statusText}${body ? ` — ${body}` : ""}`);
-        }
-        const data = await response.json();
-        return { entities: data.value ?? [] };
-      },
-    );
-  }
-
-  createRecord(entity: string, record: any): Promise<any> {
-    return logCrud({ op: "CREATE", entity, resultId: (r) => r?.id }, async () => {
-      const url = `${this.baseUrl}/api/data/v9.2/${entity}`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(record),
-      });
-      if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Create failed ${response.status}: ${body}`);
-      }
-      const entityId = response.headers.get("OData-EntityId");
-      const match = entityId ? /\(([^)]+)\)/.exec(entityId) : null;
-      return match ? { id: match[1] } : response.json().catch(() => ({}));
-    });
-  }
-
-  updateRecord(entity: string, id: string, record: any): Promise<any> {
-    return logCrud({ op: "UPDATE", entity, id }, async () => {
-      const cleanId = id.replace(/[{}]/g, "");
-      const url = `${this.baseUrl}/api/data/v9.2/${entity}(${cleanId})`;
-      const response = await fetch(url, {
-        method: "PATCH",
-        headers: this.headers(),
-        body: JSON.stringify(record),
-      });
-      if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Update failed ${response.status}: ${body}`);
-      }
-      return { success: true };
-    });
-  }
-
-  deleteRecord(entity: string, id: string): Promise<void> {
-    return logCrud({ op: "DELETE", entity, id }, async () => {
-      const cleanId = id.replace(/[{}]/g, "");
-      const url = `${this.baseUrl}/api/data/v9.2/${entity}(${cleanId})`;
-      const response = await fetch(url, { method: "DELETE", headers: this.headers() });
-      if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Delete failed ${response.status}: ${body}`);
-      }
-    });
-  }
-
-  executeRequest(requestName: string, requestData: any): Promise<any> {
-    return logCrud({ op: "EXECUTE", entity: requestName }, async () => {
-      const url = `${this.baseUrl}/api/data/v9.2/${requestName}`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(requestData),
-      });
-      if (!response.ok) {
-        const body = await response.text().catch(() => "");
-        throw new Error(`Execute failed ${response.status}: ${body}`);
-      }
-      return response.json().catch(() => ({}));
-    });
-  }
-
-  async uploadFile(file: File): Promise<string> {
-    logger.warn("uploadFile not implemented", {
-      source: "FetchApiService",
-      data: { file: file.name },
-    });
-    return "";
-  }
-
-  async associateRecord(): Promise<void> {
-    logger.warn("associateRecord not implemented", { source: "FetchApiService" });
-  }
-}

package/templates/react-custom-page/src/core/services/IApiService.ts

@@ -1,37 +0,0 @@
-// The single data-access contract for the page. Three implementations satisfy
-// it — MockApiService (offline), FetchApiService (token-proxy dev), and
-// XrmApiService (production) — and ServiceFactory picks one per environment.
-//
-// Entities are addressed by their Web API ENTITY SET name (plural, e.g.
-// "accounts"), used consistently for reads and writes across all three services.
-export interface IApiService {
-  /** Update a record. `record` contains only the changed attributes. */
-  updateRecord(entity: string, id: string, record: any): Promise<any>;
-
-  /** Create a record; resolves to `{ id }`. */
-  createRecord(entity: string, record: any): Promise<any>;
-
-  /** Delete a record. */
-  deleteRecord(entity: string, id: string): Promise<void>;
-
-  /** Retrieve records via a FetchXML query. */
-  retrieveMultipleRecords(
-    entity: string,
-    fetchXml: string,
-  ): Promise<{ entities: any[] }>;
-
-  /** Execute a custom API / unbound function or action. */
-  executeRequest(requestName: string, requestData: any): Promise<any>;
-
-  /** Upload a file and return its URL. */
-  uploadFile(file: File): Promise<string>;
-
-  /** Associate two records via a relationship. */
-  associateRecord(
-    entityName: string,
-    entityId: string,
-    relationshipName: string,
-    relatedEntityName: string,
-    relatedEntityId: string,
-  ): Promise<void>;
-}

package/templates/react-custom-page/src/core/services/ServiceFactory.ts

@@ -1,58 +0,0 @@
-import { IApiService } from "./IApiService";
-import { MockApiService } from "./MockApiService";
-import { XrmApiService } from "./XrmApiService";
-import { FetchApiService } from "./FetchApiService";
-import { logger } from "@khester/reusable-components";
-
-/**
- * Single decision point for which IApiService the page talks to.
- *
- * Priority:
- *   1. localhost + VITE_USE_PROXY → FetchApiService (real Dataverse via the Vite proxy)
- *   2. localhost (no proxy)       → injected mock, or MockApiService by default
- *   3. deployed + Xrm context     → XrmApiService
- */
-export class ServiceFactory {
-  public static isMockEnvironment: boolean =
-    window.location.hostname === "localhost" ||
-    window.location.hostname === "127.0.0.1";
-
-  /**
-   * Token-proxy dev mode. `vite.config.ts` sets `import.meta.env.VITE_USE_PROXY`
-   * to a boolean — true when DYNAMICS_URL is configured — and proxies
-   * /api/data/* to Dataverse with a server-side bearer token. Truthiness check
-   * (NOT `=== 'true'`): the `define` value is a real boolean, not a string.
-   */
-  public static isTokenMode = !!import.meta.env.VITE_USE_PROXY;
-
-  /**
-   * @param Xrm        The Xrm context (required when deployed). Resolve it from
-   *                   `window.parent?.Xrm ?? window.Xrm` in App.tsx.
-   * @param createMock Optional factory for a domain-specific mock. Used ONLY in
-   *                   mock mode (after the token-mode check), so a token session
-   *                   still talks to the real org. Defaults to MockApiService.
-   */
-  public static createApiService(
-    Xrm?: any,
-    createMock?: () => IApiService,
-  ): IApiService {
-    if (ServiceFactory.isMockEnvironment && ServiceFactory.isTokenMode) {
-      logger.info("Token mode — using FetchApiService via proxy", {
-        source: "ServiceFactory",
-      });
-      return new FetchApiService();
-    }
-
-    if (ServiceFactory.isMockEnvironment) {
-      logger.info("Mock mode — using MockApiService", {
-        source: "ServiceFactory",
-      });
-      return (createMock ?? (() => new MockApiService()))();
-    }
-
-    if (!Xrm) {
-      throw new Error("Xrm object is required in a non-mock environment.");
-    }
-    return new XrmApiService(Xrm);
-  }
-}

package/templates/react-custom-page/src/core/services/crudLogging.ts

@@ -1,52 +0,0 @@
-// Binds the generic `withCrudLog` wrapper (from @khester/reusable-components) to
-// the Dataverse error shapes thrown by the IApiService implementations, so each
-// service method can be instrumented with a single `logCrud(meta, fn)` call.
-//
-// `parseServiceError` lives here (app/template code), not in the library — the
-// library's logger stays backend-agnostic and the app injects this parser.
-
-import { withCrudLog, type CrudMeta } from "@khester/reusable-components";
-
-/**
- * Extract a numeric status + human message from the error shapes the services
- * throw: an `Error("… 400: <body>")` whose body may embed a Dataverse error
- * JSON blob, or a plain `json.error` object with a CDS InnerError message.
- */
-function parseServiceError(err: unknown): { status?: number; message?: string } {
-  if (err && typeof err === "object" && !(err instanceof Error)) {
-    const obj = err as Record<string, unknown>;
-    const inner = obj["@Microsoft.PowerApps.CDS.InnerError.Message"];
-    const message =
-      (typeof inner === "string" && inner) ||
-      (typeof obj.message === "string" && obj.message) ||
-      undefined;
-    const status = typeof obj.status === "number" ? obj.status : undefined;
-    return { status, message: message || undefined };
-  }
-
-  if (err instanceof Error) {
-    const statusMatch = err.message.match(/\b(\d{3})\b/);
-    const status = statusMatch ? Number(statusMatch[1]) : undefined;
-
-    const jsonStart = err.message.indexOf("{");
-    if (jsonStart !== -1) {
-      try {
-        const parsed = JSON.parse(err.message.substring(jsonStart));
-        const inner =
-          parsed?.error?.["@Microsoft.PowerApps.CDS.InnerError.Message"];
-        const message = inner || parsed?.error?.message || err.message;
-        return { status, message };
-      } catch {
-        // not JSON — fall through to the raw message
-      }
-    }
-    return { status, message: err.message };
-  }
-
-  return { message: String(err) };
-}
-
-/** Run a CRUD operation, emitting one structured `[CRUD] …` log line for it. */
-export function logCrud<T>(meta: CrudMeta, fn: () => Promise<T>): Promise<T> {
-  return withCrudLog(meta, fn, { parseError: parseServiceError });
-}