@burdenoff/be-sdk 2026.510.79

package/dist/chunk-FNZEQOJY.js

@@ -0,0 +1,628 @@
+import { GatewayClient } from './chunk-4B43DZIS.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+
+// src/export/index.ts
+var export_exports = {};
+__export(export_exports, {
+  BaseModuleExporter: () => BaseModuleExporter,
+  PaginationService: () => PaginationService,
+  convertToCSV: () => convertToCSV,
+  csvToJSON: () => csvToJSON,
+  estimateCSVSize: () => estimateCSVSize,
+  getCSVHeaders: () => getCSVHeaders,
+  parseCSV: () => parseCSV,
+  triggerExportJob: () => triggerExportJob
+});
+
+// src/export/base-exporter.ts
+var BaseModuleExporter = class {
+  static {
+    __name(this, "BaseModuleExporter");
+  }
+  /** Unique key identifying this module (e.g., 'users', 'tags', 'orders') */
+  moduleKey;
+  /** Human-readable display name for the module */
+  displayName;
+  /** Description of what this module exports */
+  description;
+  /** Default fields to exclude from export (e.g., sensitive data) */
+  defaultExcludeFields;
+  /** List of product IDs this exporter supports */
+  supportedProducts;
+  /** Model name for database operations */
+  modelName;
+  /**
+  * Filter fields from an entity based on exclude list
+  *
+  * Use this to remove sensitive or unnecessary fields from exported data.
+  *
+  * @param entity - Entity to filter
+  * @param excludeFields - Fields to exclude (uses defaultExcludeFields if not provided)
+  * @returns Filtered entity as a plain object
+  *
+  * @example
+  * ```typescript
+  * const user = { id: '1', name: 'John', password: 'secret', ssn: '123' };
+  * const filtered = this.filterFields(user, ['password', 'ssn']);
+  * // Result: { id: '1', name: 'John' }
+  * ```
+  */
+  filterFields(entity, excludeFields) {
+    const fieldsToExclude = excludeFields || this.defaultExcludeFields || [];
+    if (fieldsToExclude.length === 0) {
+      return entity;
+    }
+    const filtered = {};
+    const record = entity;
+    for (const [key, value] of Object.entries(record)) {
+      if (!fieldsToExclude.includes(key)) {
+        filtered[key] = value;
+      }
+    }
+    return filtered;
+  }
+  /**
+  * Filter multiple entities
+  *
+  * @param entities - Array of entities to filter
+  * @param excludeFields - Fields to exclude
+  * @returns Array of filtered entities
+  */
+  filterFieldsMany(entities, excludeFields) {
+    return entities.map((entity) => this.filterFields(entity, excludeFields));
+  }
+  /**
+  * Paginate helper for database queries
+  *
+  * Use this to implement paginated data fetching in your export method.
+  *
+  * @param queryFn - Function that executes the paginated query
+  * @param page - Page number (1-indexed)
+  * @param pageSize - Number of items per page
+  * @returns Paginated result with data and metadata
+  *
+  * @example
+  * ```typescript
+  * const result = await this.paginate(
+  *   async ({ skip, take }) => {
+  *     const items = await db.user.findMany({ skip, take });
+  *     const total = await db.user.count();
+  *     return { items, total };
+  *   },
+  *   1,
+  *   100
+  * );
+  * ```
+  */
+  async paginate(queryFn, page = 1, pageSize = 100) {
+    const skip = (page - 1) * pageSize;
+    const take = pageSize;
+    const { items, total } = await queryFn({
+      skip,
+      take
+    });
+    return {
+      data: items,
+      total,
+      hasMore: skip + items.length < total,
+      nextCursor: items.length > 0 && skip + items.length < total ? String(page + 1) : void 0
+    };
+  }
+  /**
+  * Fetch all data using cursor-based pagination
+  *
+  * Use this for exporting large datasets efficiently.
+  *
+  * @param fetchBatch - Function to fetch a batch of data
+  * @param batchSize - Number of items per batch
+  * @returns All fetched items
+  *
+  * @example
+  * ```typescript
+  * const allUsers = await this.fetchAll(
+  *   async (cursor) => db.user.findMany({
+  *     where: cursor ? { id: { gt: cursor } } : undefined,
+  *     orderBy: { id: 'asc' },
+  *     take: 100,
+  *   }),
+  *   100
+  * );
+  * ```
+  */
+  async fetchAll(fetchBatch, batchSize = 100) {
+    const allItems = [];
+    let cursor;
+    while (true) {
+      const batch = await fetchBatch(cursor);
+      if (batch.length === 0) {
+        break;
+      }
+      allItems.push(...batch);
+      const lastItem = batch[batch.length - 1];
+      if (lastItem) {
+        cursor = lastItem.id;
+      }
+      if (batch.length < batchSize) {
+        break;
+      }
+    }
+    return allItems;
+  }
+  /**
+  * Transform entity for export
+  *
+  * Override this method to customize how entities are transformed before export.
+  * Default implementation returns the entity as-is after field filtering.
+  *
+  * @param entity - Entity to transform
+  * @param excludeFields - Fields to exclude
+  * @returns Transformed entity
+  */
+  transformForExport(entity, excludeFields) {
+    return this.filterFields(entity, excludeFields);
+  }
+  /**
+  * Validate export options
+  *
+  * Override this to add custom validation for export options.
+  *
+  * @param options - Export options to validate
+  * @throws Error if options are invalid
+  */
+  validateOptions(options) {
+    const validFormats = [
+      "csv",
+      "json",
+      "xlsx"
+    ];
+    if (!validFormats.includes(options.format)) {
+      throw new Error(`Invalid export format: ${options.format}. Valid formats: ${validFormats.join(", ")}`);
+    }
+  }
+  /**
+  * Get supported export formats
+  *
+  * @returns Array of supported format strings
+  */
+  getSupportedFormats() {
+    return [
+      "csv",
+      "json",
+      "xlsx"
+    ];
+  }
+  /**
+  * Get module metadata
+  *
+  * @returns Module metadata object
+  */
+  getMetadata() {
+    return {
+      moduleKey: this.moduleKey,
+      displayName: this.displayName,
+      description: this.description,
+      supportedProducts: this.supportedProducts,
+      supportedFormats: this.getSupportedFormats()
+    };
+  }
+};
+
+// src/export/pagination.ts
+var PaginationService = class _PaginationService {
+  static {
+    __name(this, "PaginationService");
+  }
+  /**
+  * Paginate an array of items using offset-based pagination
+  *
+  * @param items - Array of items to paginate
+  * @param params - Pagination parameters
+  * @returns Paginated result with items and metadata
+  *
+  * @example
+  * ```typescript
+  * const allUsers = await db.user.findMany();
+  * const page = PaginationService.paginate(allUsers, { page: 1, pageSize: 10 });
+  * console.log(page.items); // First 10 users
+  * console.log(page.pageInfo.hasNextPage); // true if more pages exist
+  * ```
+  */
+  static paginate(items, params) {
+    const page = params.page ?? 1;
+    const pageSize = params.pageSize ?? 20;
+    const start = (page - 1) * pageSize;
+    const end = start + pageSize;
+    const paginatedItems = items.slice(start, end);
+    return {
+      items: paginatedItems,
+      totalCount: items.length,
+      pageInfo: {
+        hasNextPage: end < items.length,
+        hasPreviousPage: page > 1,
+        startCursor: paginatedItems.length > 0 ? String(start) : void 0,
+        endCursor: paginatedItems.length > 0 ? String(Math.min(end, items.length) - 1) : void 0
+      }
+    };
+  }
+  /**
+  * Calculate pagination metadata without slicing data
+  *
+  * @param totalCount - Total number of items
+  * @param page - Current page number (1-indexed)
+  * @param pageSize - Items per page
+  * @returns Pagination metadata
+  *
+  * @example
+  * ```typescript
+  * const meta = PaginationService.calculatePagination(150, 3, 20);
+  * // meta.hasNextPage = true (page 4 exists)
+  * // meta.hasPreviousPage = true (page 2 exists)
+  * // meta.totalPages = 8
+  * ```
+  */
+  static calculatePagination(totalCount, page, pageSize) {
+    const totalPages = Math.ceil(totalCount / pageSize);
+    const startIndex = (page - 1) * pageSize;
+    const endIndex = Math.min(startIndex + pageSize - 1, totalCount - 1);
+    return {
+      hasNextPage: page < totalPages,
+      hasPreviousPage: page > 1,
+      totalPages,
+      currentPage: page,
+      pageSize,
+      startIndex,
+      endIndex
+    };
+  }
+  /**
+  * Async generator for paginated database queries using cursor-based pagination
+  *
+  * This is ideal for processing large datasets without loading everything into memory.
+  * The generator yields items one at a time, fetching new batches as needed.
+  *
+  * @param fetchFn - Function to fetch data given a cursor
+  * @param options - Pagination options
+  * @returns Async generator of items
+  *
+  * @example
+  * ```typescript
+  * // Define fetch function that queries the database
+  * const fetchUsers = async (cursor?: string) => {
+  *   return db.user.findMany({
+  *     where: cursor ? { id: { gt: cursor } } : undefined,
+  *     orderBy: { id: 'asc' },
+  *     take: 100,
+  *   });
+  * };
+  *
+  * // Process all users without loading all into memory
+  * for await (const user of PaginationService.paginatedQuery(fetchUsers)) {
+  *   await processUser(user);
+  * }
+  * ```
+  */
+  static async *paginatedQuery(fetchFn, options = {}) {
+    const { limit, initialCursor } = options;
+    let cursor = initialCursor;
+    let hasMore = true;
+    let totalYielded = 0;
+    while (hasMore) {
+      const items = await fetchFn(cursor);
+      if (items.length === 0) {
+        break;
+      }
+      for (const item of items) {
+        yield item;
+        totalYielded++;
+        if (limit && totalYielded >= limit) {
+          return;
+        }
+      }
+      const lastItem = items[items.length - 1];
+      if (lastItem) {
+        cursor = lastItem.id;
+      }
+      hasMore = items.length > 0;
+    }
+  }
+  /**
+  * Collect all items from a paginated query into an array
+  *
+  * @param fetchFn - Function to fetch data given a cursor
+  * @param options - Pagination options
+  * @returns Array of all items
+  *
+  * @example
+  * ```typescript
+  * const allUsers = await PaginationService.collectPaginatedQuery(fetchUsers, { limit: 1000 });
+  * ```
+  */
+  static async collectPaginatedQuery(fetchFn, options = {}) {
+    const items = [];
+    for await (const item of _PaginationService.paginatedQuery(fetchFn, options)) {
+      items.push(item);
+    }
+    return items;
+  }
+  /**
+  * Create a cursor-based paginated fetch function from a Prisma-style query
+  *
+  * @param queryFn - Prisma-style query function
+  * @param batchSize - Number of items to fetch per batch
+  * @returns Fetch function compatible with paginatedQuery
+  *
+  * @example
+  * ```typescript
+  * const fetchFn = PaginationService.createPrismaFetchFn(
+  *   (cursor) => db.user.findMany({
+  *     where: { isActive: true, ...(cursor ? { id: { gt: cursor } } : {}) },
+  *     orderBy: { id: 'asc' },
+  *     take: 100,
+  *   }),
+  *   100
+  * );
+  *
+  * for await (const user of PaginationService.paginatedQuery(fetchFn)) {
+  *   console.log(user);
+  * }
+  * ```
+  */
+  static createPrismaFetchFn(queryFn, _batchSize = 100) {
+    return queryFn;
+  }
+  /**
+  * Calculate offset for skip-based pagination
+  *
+  * @param page - Page number (1-indexed)
+  * @param pageSize - Items per page
+  * @returns Offset value for skip
+  */
+  static calculateOffset(page, pageSize) {
+    return (Math.max(1, page) - 1) * pageSize;
+  }
+  /**
+  * Parse cursor string to extract pagination state
+  *
+  * @param cursor - Base64-encoded cursor string
+  * @returns Decoded cursor data or null if invalid
+  */
+  static parseCursor(cursor) {
+    try {
+      const decoded = Buffer.from(cursor, "base64").toString("utf-8");
+      return JSON.parse(decoded);
+    } catch {
+      return null;
+    }
+  }
+  /**
+  * Create cursor string from pagination state
+  *
+  * @param data - Data to encode in cursor
+  * @returns Base64-encoded cursor string
+  */
+  static createCursor(data) {
+    return Buffer.from(JSON.stringify(data)).toString("base64");
+  }
+};
+
+// src/export/csv.ts
+var FORMULA_PREFIX_RE = /^[=+\-@]/;
+function sanitizeCSVCell(value) {
+  return FORMULA_PREFIX_RE.test(value) ? `'${value}` : value;
+}
+__name(sanitizeCSVCell, "sanitizeCSVCell");
+function convertToCSV(data, options = {}) {
+  const { delimiter = ",", includeHeaders = true, flattenFields = true, maxFlattenDepth = 3 } = options;
+  if (data.length === 0) {
+    return "";
+  }
+  const flattenObject = /* @__PURE__ */ __name((obj, prefix = "", depth = 0) => {
+    const result = {};
+    if (obj === null || obj === void 0) {
+      return result;
+    }
+    if (typeof obj !== "object") {
+      return {
+        [prefix || "value"]: String(obj)
+      };
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      if (value === null || value === void 0) {
+        result[newKey] = "";
+      } else if (value instanceof Date) {
+        result[newKey] = value.toISOString();
+      } else if (Array.isArray(value)) {
+        result[newKey] = JSON.stringify(value);
+      } else if (typeof value === "object" && flattenFields && depth < maxFlattenDepth) {
+        Object.assign(result, flattenObject(value, newKey, depth + 1));
+      } else if (typeof value === "object") {
+        result[newKey] = JSON.stringify(value);
+      } else {
+        result[newKey] = String(value);
+      }
+    }
+    return result;
+  }, "flattenObject");
+  const flattenedRecords = data.map((item) => flattenObject(item));
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const record of flattenedRecords) {
+    for (const key of Object.keys(record)) {
+      allKeys.add(key);
+    }
+  }
+  const headers = Array.from(allKeys).sort((a, b) => a.localeCompare(b));
+  const escapeCSV = /* @__PURE__ */ __name((value) => {
+    const sanitizedValue = sanitizeCSVCell(value);
+    if (sanitizedValue.includes(delimiter) || sanitizedValue.includes('"') || sanitizedValue.includes("\n") || sanitizedValue.includes("\r")) {
+      return `"${sanitizedValue.replace(/"/g, '""')}"`;
+    }
+    return sanitizedValue;
+  }, "escapeCSV");
+  const lines = [];
+  if (includeHeaders) {
+    lines.push(headers.map(escapeCSV).join(delimiter));
+  }
+  for (const record of flattenedRecords) {
+    const row = headers.map((header) => escapeCSV(record[header] || ""));
+    lines.push(row.join(delimiter));
+  }
+  return lines.join("\n");
+}
+__name(convertToCSV, "convertToCSV");
+function parseCSV(csv, options = {}) {
+  const { delimiter = ",", hasHeaders = true } = options;
+  const lines = csv.split(/\r?\n/).filter((line) => line.trim());
+  if (lines.length === 0) {
+    return [];
+  }
+  const parseLine = /* @__PURE__ */ __name((line) => {
+    const values = [];
+    let current = "";
+    let inQuotes = false;
+    let i = 0;
+    while (i < line.length) {
+      const char = line[i];
+      const nextChar = line[i + 1];
+      if (char === '"' && inQuotes && nextChar === '"') {
+        current += '"';
+        i += 2;
+      } else if (char === '"') {
+        inQuotes = !inQuotes;
+        i++;
+      } else if (char === delimiter && !inQuotes) {
+        values.push(current);
+        current = "";
+        i++;
+      } else {
+        current += char;
+        i++;
+      }
+    }
+    values.push(current);
+    return values;
+  }, "parseLine");
+  let headers;
+  let dataLines;
+  const firstLine = lines[0];
+  if (hasHeaders) {
+    headers = parseLine(firstLine);
+    dataLines = lines.slice(1);
+  } else {
+    const firstRow = parseLine(firstLine);
+    headers = firstRow.map((_, i) => `col${i}`);
+    dataLines = lines;
+  }
+  return dataLines.map((line) => {
+    const values = parseLine(line);
+    const obj = {};
+    headers.forEach((header, i) => {
+      obj[header] = values[i] || "";
+    });
+    return obj;
+  });
+}
+__name(parseCSV, "parseCSV");
+function csvToJSON(csv, options = {}) {
+  const { pretty = false, ...parseOptions } = options;
+  const data = parseCSV(csv, parseOptions);
+  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+}
+__name(csvToJSON, "csvToJSON");
+function getCSVHeaders(data, flattenFields = true) {
+  if (data.length === 0) {
+    return [];
+  }
+  const collectKeys = /* @__PURE__ */ __name((obj, prefix = "", depth = 0) => {
+    const keys = [];
+    if (obj === null || obj === void 0 || typeof obj !== "object") {
+      return prefix ? [
+        prefix
+      ] : [];
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && flattenFields && depth < 3) {
+        keys.push(...collectKeys(value, fullKey, depth + 1));
+      } else {
+        keys.push(fullKey);
+      }
+    }
+    return keys;
+  }, "collectKeys");
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const item of data) {
+    for (const key of collectKeys(item)) {
+      allKeys.add(key);
+    }
+  }
+  return Array.from(allKeys).sort((a, b) => a.localeCompare(b));
+}
+__name(getCSVHeaders, "getCSVHeaders");
+function estimateCSVSize(data, sampleSize = 100) {
+  if (data.length === 0) {
+    return 0;
+  }
+  const sample = data.slice(0, Math.min(sampleSize, data.length));
+  const sampleCSV = convertToCSV(sample);
+  const averageRowSize = sampleCSV.length / sample.length;
+  const headers = getCSVHeaders(data);
+  const headerSize = headers.join(",").length + 1;
+  return Math.ceil(headerSize + averageRowSize * data.length);
+}
+__name(estimateCSVSize, "estimateCSVSize");
+
+// src/export/gateway-client.ts
+var CREATE_EXPORT_JOB_MUTATION = `mutation CreateExportJob($input: CreateExportJobInput!) {
+  createExportJob(input: $input) {
+    id
+    status
+    workspaceId
+    entityTypes
+    format
+    createdAt
+  }
+}`;
+async function triggerExportJob(params) {
+  const { serviceName, layer = "wspace", actorId, actorType, workspaceId, name, entityTypes, format, includeMetadata, dateRangeStart, dateRangeEnd } = params;
+  const client = new GatewayClient({
+    layer,
+    serviceName
+  });
+  const input = {
+    workspaceId,
+    name,
+    entityTypes,
+    format,
+    ...includeMetadata !== void 0 ? {
+      includeMetadata
+    } : {},
+    ...dateRangeStart !== void 0 ? {
+      dateRangeStart
+    } : {},
+    ...dateRangeEnd !== void 0 ? {
+      dateRangeEnd
+    } : {}
+  };
+  const response = await client.internalQuery({
+    query: CREATE_EXPORT_JOB_MUTATION,
+    variables: {
+      input
+    },
+    headers: {
+      "x-actor-id": actorId,
+      "x-actor-type": actorType,
+      "x-workspace-id": workspaceId
+    }
+  });
+  const job = response.data?.createExportJob;
+  if (!job) {
+    throw new Error("Export service did not return a job");
+  }
+  return job;
+}
+__name(triggerExportJob, "triggerExportJob");
+
+export { BaseModuleExporter, PaginationService, convertToCSV, csvToJSON, estimateCSVSize, export_exports, getCSVHeaders, parseCSV, triggerExportJob };
+//# sourceMappingURL=chunk-FNZEQOJY.js.map
+//# sourceMappingURL=chunk-FNZEQOJY.js.map