kobana 0.1.0

package/dist/index.js

@@ -0,0 +1,863 @@
+'use strict';
+
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/configuration.ts
+var BASE_URLS = {
+  v1: {
+    sandbox: "https://api-sandbox.kobana.com.br/v1",
+    production: "https://api.kobana.com.br/v1"
+  },
+  v2: {
+    sandbox: "https://api-sandbox.kobana.com.br/v2",
+    production: "https://api.kobana.com.br/v2"
+  }
+};
+var Configuration = class {
+  apiToken;
+  environment;
+  apiVersion;
+  customHeaders;
+  debug;
+  constructor(options) {
+    this.apiToken = options.apiToken;
+    this.environment = options.environment || "sandbox";
+    this.apiVersion = options.apiVersion || "v1";
+    this.customHeaders = options.customHeaders || {};
+    this.debug = options.debug || false;
+  }
+  getBaseUrl() {
+    return BASE_URLS[this.apiVersion][this.environment];
+  }
+  getHeaders() {
+    return {
+      Authorization: `Bearer ${this.apiToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.customHeaders
+    };
+  }
+  toString() {
+    return `Configuration { environment: ${this.environment}, apiVersion: ${this.apiVersion}, apiToken: [REDACTED] }`;
+  }
+  toJSON() {
+    return {
+      environment: this.environment,
+      apiVersion: this.apiVersion,
+      customHeaders: this.customHeaders,
+      debug: this.debug,
+      apiToken: "[REDACTED]"
+    };
+  }
+};
+
+// src/errors.ts
+var KobanaError = class _KobanaError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KobanaError";
+    Object.setPrototypeOf(this, _KobanaError.prototype);
+  }
+};
+var ConfigurationError = class _ConfigurationError extends KobanaError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+};
+var ConnectionError = class _ConnectionError extends KobanaError {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionError";
+    Object.setPrototypeOf(this, _ConnectionError.prototype);
+  }
+};
+var ResourceNotFoundError = class _ResourceNotFoundError extends KobanaError {
+  constructor(message = "Resource not found") {
+    super(message);
+    this.name = "ResourceNotFoundError";
+    Object.setPrototypeOf(this, _ResourceNotFoundError.prototype);
+  }
+};
+var UnauthorizedError = class _UnauthorizedError extends KobanaError {
+  constructor(message = "Unauthorized: Invalid or missing API token") {
+    super(message);
+    this.name = "UnauthorizedError";
+    Object.setPrototypeOf(this, _UnauthorizedError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends KobanaError {
+  errors;
+  constructor(message, errors = []) {
+    super(message);
+    this.name = "ValidationError";
+    this.errors = errors;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var APIError = class _APIError extends KobanaError {
+  status;
+  responseBody;
+  errors;
+  constructor(options) {
+    const message = options.message || `API request failed with status ${options.status}`;
+    super(message);
+    this.name = "APIError";
+    this.status = options.status;
+    this.responseBody = options.responseBody;
+    this.errors = options.errors || [];
+    Object.setPrototypeOf(this, _APIError.prototype);
+  }
+};
+
+// src/utils/string.ts
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function interpolate(template, values) {
+  return template.replace(/:(\w+)/g, (_, key) => {
+    const value = values[key];
+    return value !== void 0 ? String(value) : `:${key}`;
+  });
+}
+
+// src/utils/object.ts
+function transformKeys(obj, transformer) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => typeof item === "object" && item !== null ? transformKeys(item, transformer) : item
+    );
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = transformer(key);
+    if (typeof value === "object" && value !== null) {
+      result[newKey] = transformKeys(value, transformer);
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function keysToSnakeCase(obj) {
+  return transformKeys(obj, toSnakeCase);
+}
+function keysToCamelCase(obj) {
+  return transformKeys(obj, toCamelCase);
+}
+
+// src/resources/connection.ts
+var Connection = class {
+  axiosInstance = null;
+  configuration;
+  constructor(configuration) {
+    this.configuration = configuration;
+  }
+  getAxiosInstance() {
+    if (this.axiosInstance && !this.configuration.debug) {
+      return this.axiosInstance;
+    }
+    this.axiosInstance = axios__default.default.create({
+      baseURL: this.configuration.getBaseUrl(),
+      headers: this.configuration.getHeaders(),
+      timeout: 3e4
+    });
+    return this.axiosInstance;
+  }
+  async request(method, url, data, options = {}) {
+    const config = {
+      method,
+      url
+    };
+    if (options.idempotencyKey) {
+      config.headers = {
+        ...config.headers,
+        "X-Idempotency-Key": options.idempotencyKey
+      };
+    }
+    if (data) {
+      const transformedData = keysToSnakeCase(data);
+      if (method === "get") {
+        config.params = transformedData;
+      } else {
+        config.data = transformedData;
+      }
+    }
+    try {
+      const response = await this.getAxiosInstance().request(config);
+      const responseData = response.data ? keysToCamelCase(response.data) : response.data;
+      return {
+        data: responseData,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  async get(url, params, options) {
+    return this.request("get", url, params, options);
+  }
+  async post(url, data, options) {
+    return this.request("post", url, data, options);
+  }
+  async put(url, data, options) {
+    return this.request("put", url, data, options);
+  }
+  async patch(url, data, options) {
+    return this.request("patch", url, data, options);
+  }
+  async delete(url, options) {
+    return this.request("delete", url, void 0, options);
+  }
+  handleError(error) {
+    if (axios__default.default.isAxiosError(error)) {
+      const axiosError = error;
+      if (!axiosError.response) {
+        return new ConnectionError(
+          axiosError.message || "Network error: Unable to connect to API"
+        );
+      }
+      const { status, data } = axiosError.response;
+      const errors = [];
+      if (data?.errors && Array.isArray(data.errors)) {
+        errors.push(...data.errors.map((e) => e.message || String(e)));
+      } else if (data?.error) {
+        errors.push(data.error);
+      } else if (data?.message) {
+        errors.push(data.message);
+      }
+      switch (status) {
+        case 401:
+          return new UnauthorizedError(errors[0]);
+        case 404:
+          return new ResourceNotFoundError(errors[0]);
+        default:
+          return new APIError({
+            status,
+            responseBody: data,
+            errors,
+            message: errors[0]
+          });
+      }
+    }
+    if (error instanceof Error) {
+      return new ConnectionError(error.message);
+    }
+    return new ConnectionError("An unknown error occurred");
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  static resourceEndpoint = "";
+  static primaryKeyField = "id";
+  static _connection;
+  _connection;
+  _attributes;
+  _errors = [];
+  _created = false;
+  _updated = false;
+  constructor(attributes = {}, connection) {
+    this._attributes = { ...attributes };
+    this._connection = connection;
+  }
+  static withConnection(connection) {
+    const ParentClass = this;
+    const BoundClass = class extends ParentClass {
+      static _connection = connection;
+      constructor(attributes = {}) {
+        super(attributes, connection);
+      }
+    };
+    BoundClass.resourceEndpoint = this.resourceEndpoint;
+    BoundClass.primaryKeyField = this.primaryKeyField;
+    return BoundClass;
+  }
+  static getConnection() {
+    if (!this._connection) {
+      throw new Error(
+        "No connection available. Use withConnection() or create a client first."
+      );
+    }
+    return this._connection;
+  }
+  static getUri(attributes = {}) {
+    const endpoint = this.resourceEndpoint;
+    const id = attributes[this.primaryKeyField];
+    if (id !== void 0) {
+      return interpolate(`${endpoint}/:${this.primaryKeyField}`, {
+        [this.primaryKeyField]: id
+      });
+    }
+    return endpoint;
+  }
+  static async create(attributes, options) {
+    const connection = this.getConnection();
+    const response = await connection.post(
+      this.resourceEndpoint,
+      attributes,
+      options
+    );
+    const instance = new this(response.data, connection);
+    instance._created = true;
+    return instance;
+  }
+  static async find(id, params) {
+    const connection = this.getConnection();
+    const url = this.getUri({ [this.primaryKeyField]: id });
+    try {
+      const response = await connection.get(url, params);
+      return new this(response.data, connection);
+    } catch (error) {
+      if (error.name === "ResourceNotFoundError") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  static async all(params) {
+    const connection = this.getConnection();
+    const response = await connection.get(
+      this.resourceEndpoint,
+      params
+    );
+    if (!Array.isArray(response.data)) {
+      return [];
+    }
+    return response.data.map((attrs) => new this(attrs, connection));
+  }
+  static async findBy(params) {
+    const results = await this.all(params);
+    return results.length > 0 ? results[0] : null;
+  }
+  static async findOrCreateBy(params, attributes, options) {
+    const existing = await this.findBy(params);
+    if (existing) {
+      return existing;
+    }
+    return this.create({ ...params, ...attributes }, options);
+  }
+  get attributes() {
+    return { ...this._attributes };
+  }
+  get errors() {
+    return [...this._errors];
+  }
+  get(key) {
+    return this._attributes[key];
+  }
+  set(key, value) {
+    this._attributes[key] = value;
+  }
+  get id() {
+    const Constructor = this.constructor;
+    return this._attributes[Constructor.primaryKeyField];
+  }
+  isNewRecord() {
+    return this.id === void 0;
+  }
+  isCreated() {
+    return this._created;
+  }
+  isUpdated() {
+    return this._updated;
+  }
+  isValid() {
+    return this._errors.length === 0;
+  }
+  getUri() {
+    const Constructor = this.constructor;
+    return Constructor.getUri(this._attributes);
+  }
+  getConnection() {
+    if (!this._connection) {
+      const Constructor = this.constructor;
+      return Constructor.getConnection();
+    }
+    return this._connection;
+  }
+  async save(options) {
+    const connection = this.getConnection();
+    const Constructor = this.constructor;
+    if (this.isNewRecord()) {
+      const response = await connection.post(
+        Constructor.resourceEndpoint,
+        this._attributes,
+        options
+      );
+      this._attributes = response.data;
+      this._created = true;
+    } else {
+      const response = await connection.put(
+        this.getUri(),
+        this._attributes,
+        options
+      );
+      this._attributes = response.data;
+      this._updated = true;
+    }
+    return this;
+  }
+  async update(newAttributes, options) {
+    this._attributes = { ...this._attributes, ...newAttributes };
+    const connection = this.getConnection();
+    const response = await connection.put(
+      this.getUri(),
+      this._attributes,
+      options
+    );
+    this._attributes = response.data;
+    this._updated = true;
+    return this;
+  }
+  async delete() {
+    const connection = this.getConnection();
+    try {
+      await connection.delete(this.getUri());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  toJSON() {
+    return this.attributes;
+  }
+};
+
+// src/resources/charge/pix.ts
+var Pix = class extends BaseResource {
+  static resourceEndpoint = "/charge/pix";
+  get amount() {
+    return this.get("amount");
+  }
+  get expireAt() {
+    return this.get("expireAt");
+  }
+  get status() {
+    return this.get("status");
+  }
+  get customerPersonName() {
+    return this.get("customerPersonName");
+  }
+  get customerCnpjCpf() {
+    return this.get("customerCnpjCpf");
+  }
+  get customerEmail() {
+    return this.get("customerEmail");
+  }
+  get customerPhoneNumber() {
+    return this.get("customerPhoneNumber");
+  }
+  get description() {
+    return this.get("description");
+  }
+  get meta() {
+    return this.get("meta");
+  }
+  get qrCode() {
+    return this.get("qrCode");
+  }
+  get qrCodeUrl() {
+    return this.get("qrCodeUrl");
+  }
+  get copyPaste() {
+    return this.get("copyPaste");
+  }
+  get txid() {
+    return this.get("txid");
+  }
+  get paidAt() {
+    return this.get("paidAt");
+  }
+  get paidAmount() {
+    return this.get("paidAmount");
+  }
+  get createdAt() {
+    return this.get("createdAt");
+  }
+  get updatedAt() {
+    return this.get("updatedAt");
+  }
+  static async create(attributes, options) {
+    return super.create(attributes, options);
+  }
+  static async find(id, params) {
+    return super.find(id, params);
+  }
+  static async all(params) {
+    return super.all(params);
+  }
+  static async findBy(params) {
+    return super.findBy(params);
+  }
+  isPending() {
+    return this.status === "pending";
+  }
+  isPaid() {
+    return this.status === "paid";
+  }
+  isCanceled() {
+    return this.status === "canceled";
+  }
+  isExpired() {
+    return this.status === "expired";
+  }
+};
+
+// src/resources/charge/bank-billet.ts
+var BankBillet = class extends BaseResource {
+  static resourceEndpoint = "/bank_billets";
+  get amount() {
+    return this.get("amount");
+  }
+  get expireAt() {
+    return this.get("expireAt");
+  }
+  get customerPersonName() {
+    return this.get("customerPersonName");
+  }
+  get customerCnpjCpf() {
+    return this.get("customerCnpjCpf");
+  }
+  get customerState() {
+    return this.get("customerState");
+  }
+  get customerCityName() {
+    return this.get("customerCityName");
+  }
+  get customerZipcode() {
+    return this.get("customerZipcode");
+  }
+  get customerAddress() {
+    return this.get("customerAddress");
+  }
+  get customerNeighborhood() {
+    return this.get("customerNeighborhood");
+  }
+  get customerAddressNumber() {
+    return this.get("customerAddressNumber");
+  }
+  get customerAddressComplement() {
+    return this.get("customerAddressComplement");
+  }
+  get customerPhoneNumber() {
+    return this.get("customerPhoneNumber");
+  }
+  get customerEmail() {
+    return this.get("customerEmail");
+  }
+  get bankBilletAccountId() {
+    return this.get("bankBilletAccountId");
+  }
+  get ourNumber() {
+    return this.get("ourNumber");
+  }
+  get status() {
+    return this.get("status");
+  }
+  get shippingStatus() {
+    return this.get("shippingStatus");
+  }
+  get meta() {
+    return this.get("meta");
+  }
+  get notes() {
+    return this.get("notes");
+  }
+  get instructions() {
+    return this.get("instructions");
+  }
+  get pixEnabled() {
+    return this.get("pixEnabled");
+  }
+  get createdAt() {
+    return this.get("createdAt");
+  }
+  get updatedAt() {
+    return this.get("updatedAt");
+  }
+  static async create(attributes, options) {
+    return super.create(attributes, options);
+  }
+  static async find(id, params) {
+    return super.find(id, params);
+  }
+  static async all(params) {
+    return super.all(params);
+  }
+  static async findBy(params) {
+    return super.findBy(params);
+  }
+  isPending() {
+    return this.status === "pending";
+  }
+  isOpened() {
+    return this.status === "opened";
+  }
+  isPaid() {
+    return this.status === "paid";
+  }
+  isCanceled() {
+    return this.status === "canceled";
+  }
+  isExpired() {
+    return this.status === "expired";
+  }
+};
+
+// src/resources/financial/bank-billet-account.ts
+var BankBilletAccount = class extends BaseResource {
+  static resourceEndpoint = "/bank_billet_accounts";
+  get bankContractSlug() {
+    return this.get("bankContractSlug");
+  }
+  get nextOurNumber() {
+    return this.get("nextOurNumber");
+  }
+  get agencyNumber() {
+    return this.get("agencyNumber");
+  }
+  get agencyDigit() {
+    return this.get("agencyDigit");
+  }
+  get accountNumber() {
+    return this.get("accountNumber");
+  }
+  get accountDigit() {
+    return this.get("accountDigit");
+  }
+  get extra1() {
+    return this.get("extra1");
+  }
+  get extra1Digit() {
+    return this.get("extra1Digit");
+  }
+  get extra2() {
+    return this.get("extra2");
+  }
+  get extra2Digit() {
+    return this.get("extra2Digit");
+  }
+  get beneficiaryName() {
+    return this.get("beneficiaryName");
+  }
+  get beneficiaryCnpjCpf() {
+    return this.get("beneficiaryCnpjCpf");
+  }
+  get beneficiaryAddress() {
+    return this.get("beneficiaryAddress");
+  }
+  get name() {
+    return this.get("name");
+  }
+  get status() {
+    return this.get("status");
+  }
+  get homologatedAt() {
+    return this.get("homologatedAt");
+  }
+  get nextRemittanceNumber() {
+    return this.get("nextRemittanceNumber");
+  }
+  get configuration() {
+    return this.get("configuration");
+  }
+  get createdAt() {
+    return this.get("createdAt");
+  }
+  get updatedAt() {
+    return this.get("updatedAt");
+  }
+  static async create(attributes, options) {
+    return super.create(attributes, options);
+  }
+  static async find(id, params) {
+    return super.find(id, params);
+  }
+  static async all(params) {
+    return super.all(params);
+  }
+  static async findBy(params) {
+    return super.findBy(params);
+  }
+  async askHomologation() {
+    const connection = this.getConnection();
+    const response = await connection.get(
+      `${this.getUri()}/ask`
+    );
+    this._attributes = response.data;
+    return this;
+  }
+  async validate() {
+    const connection = this.getConnection();
+    const response = await connection.put(
+      `${this.getUri()}/validate`,
+      {}
+    );
+    this._attributes = response.data;
+    return this;
+  }
+  async setDefault() {
+    const connection = this.getConnection();
+    const response = await connection.put(
+      `${this.getUri()}/set_default`,
+      {}
+    );
+    this._attributes = response.data;
+    return this;
+  }
+  isPending() {
+    return this.status === "pending";
+  }
+  isHomologating() {
+    return this.status === "homologating";
+  }
+  isActive() {
+    return this.status === "active";
+  }
+  isHomologated() {
+    return this.homologatedAt !== void 0;
+  }
+};
+
+// src/client.ts
+function createChargeProxy(connection) {
+  let pixResource = null;
+  let bankBilletResource = null;
+  return {
+    get pix() {
+      if (!pixResource) {
+        pixResource = Pix.withConnection(connection);
+      }
+      return pixResource;
+    },
+    get bankBillet() {
+      if (!bankBilletResource) {
+        bankBilletResource = BankBillet.withConnection(connection);
+      }
+      return bankBilletResource;
+    }
+  };
+}
+function createFinancialProxy(connection) {
+  let bankBilletAccountResource = null;
+  return {
+    get bankBilletAccount() {
+      if (!bankBilletAccountResource) {
+        bankBilletAccountResource = BankBilletAccount.withConnection(
+          connection
+        );
+      }
+      return bankBilletAccountResource;
+    }
+  };
+}
+var KobanaClient = class {
+  _configuration;
+  _connection;
+  _chargeProxy = null;
+  _financialProxy = null;
+  constructor(options) {
+    this._configuration = new Configuration(options);
+    this._connection = new Connection(this._configuration);
+  }
+  get configuration() {
+    return this._configuration;
+  }
+  configure(options) {
+    if (options.apiToken !== void 0) {
+      this._configuration.apiToken = options.apiToken;
+    }
+    if (options.environment !== void 0) {
+      this._configuration.environment = options.environment;
+    }
+    if (options.apiVersion !== void 0) {
+      this._configuration.apiVersion = options.apiVersion;
+    }
+    if (options.customHeaders !== void 0) {
+      this._configuration.customHeaders = options.customHeaders;
+    }
+    if (options.debug !== void 0) {
+      this._configuration.debug = options.debug;
+    }
+    this._connection = new Connection(this._configuration);
+    this._chargeProxy = null;
+    this._financialProxy = null;
+  }
+  get charge() {
+    if (!this._chargeProxy) {
+      this._chargeProxy = createChargeProxy(this._connection);
+    }
+    return this._chargeProxy;
+  }
+  get financial() {
+    if (!this._financialProxy) {
+      this._financialProxy = createFinancialProxy(this._connection);
+    }
+    return this._financialProxy;
+  }
+};
+var globalConfiguration = null;
+var globalConnection = null;
+var globalChargeProxy = null;
+var globalFinancialProxy = null;
+function getGlobalConnection() {
+  if (!globalConnection) {
+    throw new Error("Kobana not configured. Call Kobana.configure() first.");
+  }
+  return globalConnection;
+}
+var Kobana = {
+  configure(options) {
+    globalConfiguration = new Configuration(options);
+    globalConnection = new Connection(globalConfiguration);
+    globalChargeProxy = null;
+    globalFinancialProxy = null;
+  },
+  get configuration() {
+    return globalConfiguration;
+  },
+  get charge() {
+    if (!globalChargeProxy) {
+      globalChargeProxy = createChargeProxy(getGlobalConnection());
+    }
+    return globalChargeProxy;
+  },
+  get financial() {
+    if (!globalFinancialProxy) {
+      globalFinancialProxy = createFinancialProxy(getGlobalConnection());
+    }
+    return globalFinancialProxy;
+  },
+  Client: KobanaClient
+};
+
+exports.APIError = APIError;
+exports.BankBillet = BankBillet;
+exports.BankBilletAccount = BankBilletAccount;
+exports.BaseResource = BaseResource;
+exports.Configuration = Configuration;
+exports.ConfigurationError = ConfigurationError;
+exports.Connection = Connection;
+exports.ConnectionError = ConnectionError;
+exports.Kobana = Kobana;
+exports.KobanaClient = KobanaClient;
+exports.KobanaError = KobanaError;
+exports.Pix = Pix;
+exports.ResourceNotFoundError = ResourceNotFoundError;
+exports.UnauthorizedError = UnauthorizedError;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map