@neo-edi/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,512 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NeoEdiApiError: () => NeoEdiApiError,
+  NeoEdiClient: () => NeoEdiClient,
+  NeoEdiError: () => NeoEdiError,
+  NeoEdiNetworkError: () => NeoEdiNetworkError,
+  NeoEdiValidationError: () => NeoEdiValidationError,
+  Queries: () => Queries
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var NeoEdiError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "NeoEdiError";
+  }
+};
+var NeoEdiApiError = class extends NeoEdiError {
+  constructor(message, statusCode, code, details) {
+    super(message, code, statusCode, details);
+    this.statusCode = statusCode;
+    this.name = "NeoEdiApiError";
+  }
+};
+var NeoEdiNetworkError = class extends NeoEdiError {
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR");
+    this.cause = cause;
+    this.name = "NeoEdiNetworkError";
+  }
+};
+var NeoEdiValidationError = class extends NeoEdiError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "NeoEdiValidationError";
+  }
+};
+
+// src/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e4;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      "X-SDK-Version": "0.1.0",
+      ...config.headers
+    };
+  }
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const headers = {
+      ...this.defaultHeaders,
+      "X-API-Key": this.apiKey,
+      ...options.headers
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      let body;
+      let finalHeaders = headers;
+      if (options.body instanceof FormData) {
+        body = options.body;
+        const { "Content-Type": _, ...restHeaders } = finalHeaders;
+        finalHeaders = restHeaders;
+      } else if (options.body) {
+        body = JSON.stringify(options.body);
+      }
+      const response = await fetch(url, {
+        method: options.method,
+        headers: finalHeaders,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await this.parseResponse(response);
+      if (!response.ok) {
+        throw new NeoEdiApiError(
+          data.error || `Request failed with status ${response.status}`,
+          response.status,
+          data.code,
+          data.details
+        );
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof NeoEdiApiError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NeoEdiNetworkError("Request timeout", error);
+        }
+        throw new NeoEdiNetworkError(error.message, error);
+      }
+      throw new NeoEdiNetworkError("Unknown error occurred");
+    }
+  }
+  buildUrl(path, query) {
+    const url = new URL(path, this.baseUrl);
+    if (query) {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  async parseResponse(response) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      try {
+        return await response.json();
+      } catch {
+        return { error: "Invalid JSON response" };
+      }
+    }
+    const text = await response.text();
+    return { data: text };
+  }
+  // Convenience methods
+  get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  post(path, body) {
+    return this.request({ method: "POST", path, body });
+  }
+  patch(path, body) {
+    return this.request({ method: "PATCH", path, body });
+  }
+  put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+};
+
+// src/resources/customers.ts
+var CustomersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all customers
+   */
+  async list(params) {
+    const response = await this.http.get(
+      "/api/v1/customers",
+      params
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Get a customer by ID
+   */
+  async get(customerId) {
+    const response = await this.http.get(
+      `/api/v1/customers/${encodeURIComponent(customerId)}`
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Create a new customer
+   */
+  async create(data) {
+    const response = await this.http.post(
+      "/api/v1/customers",
+      data
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Update a customer
+   */
+  async update(customerId, data) {
+    const response = await this.http.patch(
+      `/api/v1/customers/${encodeURIComponent(customerId)}`,
+      data
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Delete a customer
+   */
+  async delete(customerId) {
+    await this.http.delete(
+      `/api/v1/customers/${encodeURIComponent(customerId)}`
+    );
+  }
+};
+
+// src/resources/partner-customers.ts
+var PartnerCustomersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Register customer-partner relationships
+   * Creates or activates relationships between a customer and multiple trading partners
+   */
+  async register(data) {
+    const response = await this.http.post(
+      "/api/v1/partner-customers",
+      data
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+};
+
+// src/resources/mapping-templates.ts
+var MappingTemplatesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * List all mapping templates
+   */
+  async list(params) {
+    const response = await this.http.get(
+      "/api/v1/mapping-templates",
+      params
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Get a mapping template by ID
+   */
+  async get(templateId) {
+    const response = await this.http.get(
+      `/api/v1/mapping-templates/${encodeURIComponent(templateId)}`
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Create a new mapping template
+   */
+  async create(data) {
+    const response = await this.http.post(
+      "/api/v1/mapping-templates",
+      data
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Update a mapping template
+   */
+  async update(templateId, data) {
+    const response = await this.http.put(
+      `/api/v1/mapping-templates/${encodeURIComponent(templateId)}`,
+      data
+    );
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Delete a mapping template
+   */
+  async delete(templateId) {
+    await this.http.delete(
+      `/api/v1/mapping-templates/${encodeURIComponent(templateId)}`
+    );
+  }
+};
+
+// src/resources/ingest.ts
+var IngestResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload a CSV file for ingestion
+   *
+   * @example Browser
+   * ```typescript
+   * const input = document.querySelector('input[type="file"]');
+   * const file = input.files[0];
+   * await client.ingest.uploadCsv(file, options);
+   * ```
+   *
+   * @example Node.js
+   * ```typescript
+   * import { readFileSync } from 'fs';
+   * const buffer = readFileSync('data.csv');
+   * const blob = new Blob([buffer], { type: 'text/csv' });
+   * await client.ingest.uploadCsv(blob, options);
+   * ```
+   */
+  async uploadCsv(file, options) {
+    const formData = new FormData();
+    formData.append("file", file, "data.csv");
+    formData.append("partnerId", options.partnerId);
+    formData.append("mappingConfig", JSON.stringify(options.mappingConfig));
+    if (options.transformationConfig) {
+      formData.append(
+        "transformationConfig",
+        JSON.stringify(options.transformationConfig)
+      );
+    }
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/ingest-csv",
+      body: formData
+    });
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+  /**
+   * Perform a dry run of CSV ingestion (validation only)
+   */
+  async dryRun(file, options) {
+    const formData = new FormData();
+    formData.append("file", file, "data.csv");
+    formData.append("partnerId", options.partnerId);
+    formData.append("mappingConfig", JSON.stringify(options.mappingConfig));
+    if (options.transformationConfig) {
+      formData.append(
+        "transformationConfig",
+        JSON.stringify(options.transformationConfig)
+      );
+    }
+    const response = await this.http.request({
+      method: "POST",
+      path: "/api/v1/ingest-csv/dry-run",
+      body: formData
+    });
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response.data;
+  }
+};
+
+// src/resources/graphql.ts
+var GraphQLResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Execute a GraphQL query
+   */
+  async query(query, variables, options) {
+    const response = await this.http.post("/api/v1/graphql", {
+      query,
+      variables,
+      operationName: options?.operationName
+    });
+    if (response.errors && response.errors.length > 0) {
+      const errorMessage = response.errors.map((e) => e.message).join("; ");
+      throw new Error(`GraphQL Error: ${errorMessage}`);
+    }
+    if (!response.data) {
+      throw new Error("No data returned from GraphQL query");
+    }
+    return response.data;
+  }
+  /**
+   * Execute a GraphQL mutation
+   */
+  async mutate(mutation, variables, options) {
+    return this.query(mutation, variables, options);
+  }
+};
+var Queries = {
+  /**
+   * Get EDI 852 headers with filtering
+   */
+  GET_EDI_852_HEADERS: `
+    query GetEdi852Headers($filter: Edi852HeaderFilterInput) {
+      edi852Headers(filter: $filter) {
+        id
+        documentId
+        reportTypeCode
+        reportDate
+        vendorPartnerId
+        retailerPartnerId
+        status
+        totalLocations
+        totalItems
+        createdAt
+      }
+    }
+  `,
+  /**
+   * Get a single EDI 852 header by ID with locations
+   */
+  GET_EDI_852_HEADER_BY_ID: `
+    query GetEdi852HeaderById($id: ID!) {
+      edi852Header(id: $id) {
+        id
+        documentId
+        reportTypeCode
+        reportDate
+        vendorPartnerId
+        retailerPartnerId
+        status
+        totalLocations
+        totalItems
+        metadata
+        createdAt
+        locations {
+          id
+          locationNumber
+          locationName
+          activityDate
+          items {
+            id
+            upc
+            productDescription
+            quantityOnHand
+            quantitySold
+            unitCost
+          }
+        }
+      }
+    }
+  `,
+  /**
+   * Get trading partner execution summaries
+   */
+  GET_EXECUTION_SUMMARIES: `
+    query GetExecutionSummaries($partnerId: ID!) {
+      tradingPartnerExecutionSummaries(partnerId: $partnerId) {
+        tradingPartnerId
+        customerId
+        lastExecutedAt
+        documentCount
+      }
+    }
+  `
+};
+
+// src/client.ts
+var NeoEdiClient = class {
+  constructor(config) {
+    this.http = new HttpClient({
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      timeout: config.timeout,
+      headers: config.headers
+    });
+    this.customers = new CustomersResource(this.http);
+    this.partnerCustomers = new PartnerCustomersResource(this.http);
+    this.mappingTemplates = new MappingTemplatesResource(this.http);
+    this.ingest = new IngestResource(this.http);
+    this.graphql = new GraphQLResource(this.http);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NeoEdiApiError,
+  NeoEdiClient,
+  NeoEdiError,
+  NeoEdiNetworkError,
+  NeoEdiValidationError,
+  Queries
+});