@jogolabs/billing-sdk-v2 0.0.1

package/dist/billing/src/__generated__/services/SubscriptionsService.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionsService = void 0;
+class SubscriptionsService {
+    httpRequest;
+    constructor(httpRequest) {
+        this.httpRequest = httpRequest;
+    }
+    /**
+     * Crear y pagar una suscripción
+     * Crea una suscripción para el cliente autenticado y ejecuta el cobro al proveedor de pago configurado para el negocio.
+     * **Flujo con tarjeta guardada (recomendado para renovaciones):** Enviar `savedCardId` + `cvv`. Si el pago completa de inmediato, retorna `201` con la suscripción activa.
+     * **Flujo con tarjeta nueva (3DS):** Enviar datos de tarjeta directamente. Wompi puede requerir autenticación 3DS, en cuyo caso retorna `202` con un `redirectUrl`. Redirigir al cliente a esa URL. La suscripción se activará automáticamente cuando Wompi envíe el webhook de confirmación.
+     *
+     * @returns CreateSubscriptionResponse Suscripción creada y activa (pago completado sin 3DS)
+     * @throws ApiError
+     */
+    postApiV1Subscriptions({ requestBody, }) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/subscriptions',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Datos de pago incompletos`,
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+    /**
+     * Mis suscripciones
+     * Retorna todas las suscripciones del cliente autenticado.
+     * @returns Subscription Lista de suscripciones del cliente
+     * @throws ApiError
+     */
+    getApiV1SubscriptionsMe() {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/subscriptions/me',
+            errors: {
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+    /**
+     * Suscripciones de un cliente (admin)
+     * Retorna las suscripciones de un cliente específico. Uso interno/admin — el negocio puede consultar el estado de sus clientes.
+     *
+     * @returns Subscription Lista de suscripciones
+     * @throws ApiError
+     */
+    getApiV1SubscriptionsCustomer({ customerId, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/subscriptions/customer/{customerId}',
+            path: {
+                'customerId': customerId,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+    /**
+     * Detalle de una suscripción
+     * @returns Subscription Detalle de la suscripción con info del paquete populada
+     * @throws ApiError
+     */
+    getApiV1Subscriptions({ id, }) {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/subscriptions/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                404: `Suscripción no encontrada`,
+            },
+        });
+    }
+    /**
+     * Registrar uso de una clase
+     * Descuenta una clase del saldo disponible en la suscripción. Solo aplica a suscripciones en estado `active` con clases restantes.
+     *
+     * @returns ConsumeClassResponse Clase registrada exitosamente
+     * @throws ApiError
+     */
+    postApiV1SubscriptionsConsume({ id, }) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/subscriptions/{id}/consume',
+            path: {
+                'id': id,
+            },
+            errors: {
+                400: `Sin clases disponibles o suscripción inactiva/vencida`,
+                401: `Token JWT ausente o inválido`,
+                403: `La suscripción no pertenece al cliente`,
+            },
+        });
+    }
+    /**
+     * Cancelar suscripción
+     * Cancela la suscripción y desactiva la renovación automática. El cliente mantiene acceso hasta la fecha de vencimiento.
+     *
+     * @returns Subscription Suscripción cancelada
+     * @throws ApiError
+     */
+    postApiV1SubscriptionsCancel({ id, }) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/subscriptions/{id}/cancel',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                403: `Forbidden`,
+                409: `La suscripción ya está cancelada`,
+            },
+        });
+    }
+    /**
+     * Renovar suscripción manualmente
+     * Renueva una suscripción usando la tarjeta guardada previamente. Requiere CVV por cumplimiento PCI. Si el pago requiere 3DS, retorna `redirectUrl` para completar la autenticación.
+     *
+     * @returns CreateSubscriptionResponse Suscripción renovada
+     * @throws ApiError
+     */
+    postApiV1SubscriptionsRenew({ id, requestBody, }) {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/subscriptions/{id}/renew',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `CVV requerido o no hay tarjeta guardada`,
+                401: `Token JWT ausente o inválido`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}
+exports.SubscriptionsService = SubscriptionsService;

package/dist/billing/src/index.d.ts

@@ -0,0 +1 @@
+export * from './__generated__';

package/dist/billing/src/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./__generated__"), exports);

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { OpenAPIConfig, BaseHttpRequest, Billing, CancelablePromise } from './billing/src';
+import { ApiRequestOptions } from './billing/src/__generated__/core/ApiRequestOptions';
+export * from './billing/src';
+export declare const billingInstance: (baseUrl: string) => AxiosInstance;
+export declare class BillingHttpClient extends BaseHttpRequest {
+    axiosInstance: AxiosInstance;
+    constructor(config: OpenAPIConfig);
+    request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+export declare const createBillingApiClient: (baseUrl: string, tokenProp?: string) => Billing;

package/dist/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBillingApiClient = exports.BillingHttpClient = exports.billingInstance = void 0;
+const src_1 = require("./billing/src");
+const axios_1 = __importDefault(require("axios"));
+const request_1 = require("./billing/src/__generated__/core/request");
+// export all sdk
+__exportStar(require("./billing/src"), exports);
+let token = '';
+const billingInstance = (baseUrl) => {
+    return axios_1.default.create({
+        baseURL: baseUrl,
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: token ? `Bearer ${token}` : undefined,
+        },
+    });
+};
+exports.billingInstance = billingInstance;
+class BillingHttpClient extends src_1.BaseHttpRequest {
+    axiosInstance;
+    constructor(config) {
+        super(config);
+        this.axiosInstance = (0, exports.billingInstance)(config.BASE);
+    }
+    request(options) {
+        return (0, request_1.request)(this.config, options, this.axiosInstance);
+    }
+}
+exports.BillingHttpClient = BillingHttpClient;
+const createBillingApiClient = (baseUrl, tokenProp) => {
+    token = tokenProp;
+    return new src_1.Billing({
+        BASE: baseUrl,
+    }, BillingHttpClient);
+};
+exports.createBillingApiClient = createBillingApiClient;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@jogolabs/billing-sdk-v2",
+  "version": "0.0.1",
+  "description": "Billing SDK v2 to Jogo Labs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "react-native": "dist/index.js",
+  "source": "src/index.ts",
+  "prepublish": "tsc --composite false",
+  "public": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "node scripts/generate-api-sdk.js generate-sdk --url http://localhost:3003 --name 'Billing' -o 'src/billing' && tsc --composite false",
+    "deploy": "npm run build && npm publish --access public",
+    "publish:package": "node ./scripts/publish.js"
+  },
+  "author": "rivaslive",
+  "license": "ISC",
+  "packageManager": "yarn@1.22.22+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610",
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.5.0",
+    "@typescript-eslint/parser": "^8.5.0",
+    "axios": "^1.7.7",
+    "eslint": "^8.57.1",
+    "json-schema-ref-parser": "^9.0.9",
+    "openapi-typescript-codegen": "^0.29.0",
+    "typescript": "^5.6.2",
+    "yargs": "^17.7.2"
+  },
+  "peerDependencies": {
+    "axios": "^1.x.x"
+  },
+  "dependencies": {
+    "inquirer": "^13.3.0"
+  }
+}

package/scripts/generate-api-sdk.js

@@ -0,0 +1,86 @@
+const generator = require('openapi-typescript-codegen');
+const $RefParser = require('json-schema-ref-parser');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const fs = require('fs');
+
+const parseJson = (text) => {
+  // Controllers names
+  text = text.replace(/[a-zA-Z0-9]+Controller/g, '')
+
+  return JSON.parse(text)
+}
+
+const generateClientSdk = async (apiBaseUrl, clientName, outputPath = './') => {
+  try {
+    console.log(`Fetching Swagger from ${apiBaseUrl}/docs/spec.json...`);
+    const jsonSwagger = await fetch(`${apiBaseUrl}/docs/spec.json`)
+      .then((r) => r.text())
+      .then(parseJson)
+      .catch((err) => console.error(err));
+
+    if (!jsonSwagger) throw new Error('Swagger not found');
+    console.log('Swagger Acquired. Generating SDK...');
+
+    const input = JSON.stringify(jsonSwagger);
+    const json = parseJson(input);
+
+    const parsed = await $RefParser.parse(json);
+    await generator.generate({
+      input: parsed,
+      output: outputPath + '/src/__generated__',
+      clientName: clientName,
+      useUnionTypes: false,
+      httpClient: 'axios',
+      useOptions: true,
+      exportSchemas: true,
+    });
+    console.log('SDK Generated. Updating package.json...');
+
+    fs.writeFileSync(`${outputPath}/src/index.ts`, "export * from './__generated__';\n");
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+  console.log('Done');
+  process.exit(0);
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const argv = yargs(hideBin(process.argv))
+  .command(
+    'generate-sdk',
+    'Generate the SDK',
+    (yargs) => {
+      yargs
+        .option('url', {
+          alias: 'u',
+          description: 'Url to the App api swagger-json',
+          type: 'string',
+          demandOption: true,
+        })
+        .option('name', {
+          alias: 'n',
+          description: 'Client name',
+          type: 'string',
+          demandOption: true,
+        })
+        .option('output', {
+          alias: 'o',
+          description: 'Output directory for generated SDK',
+          type: 'string',
+          default: 'generated/rest-client',
+        });
+    },
+    (argv) => {
+      generateClientSdk(argv.url, argv.name, argv.output);
+    },
+  )
+  .demandCommand(1, 'You need at least one command before moving on')
+  .help()
+  .alias('h', 'help').argv;
+
+/**
+ * example:
+ * node tools/scripts/generateSdkApiClient.js generate-sdk --url $API_URL --name 'AppName' -o './libs/public/<app-name-sdk>/src'"
+ */

package/scripts/publish.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const inquirer = require('inquirer');
+const { hideBin } = require('yargs/helpers');
+const path = require('path');
+const yargs = require('yargs/yargs')(hideBin(process.argv));
+
+(async () => {
+  // Settings yargs for the command line
+  const argv = yargs.option('auto', {
+    alias: 'a',
+    type: 'boolean',
+    description: 'Use the arg in the line command (major, minor, patch)',
+  }).argv;
+
+  const pkgPath = path.resolve(__dirname, '..', './package.json');
+
+  const packageJson = JSON.parse(fs.readFileSync(pkgPath));
+
+  const version = packageJson.version;
+
+  let versionType = argv._[0];
+
+  if (!versionType || !['major', 'minor', 'patch'].includes(versionType)) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'versionType',
+        message: 'What type of version do you want to update?',
+        choices: ['major', 'minor', 'patch'],
+      },
+    ]);
+    versionType = answers.versionType;
+  }
+
+  const versionArray = version.split('.');
+
+  switch (versionType) {
+    case 'major':
+      versionArray[0] = parseInt(versionArray[0]) + 1;
+      break;
+    case 'minor':
+      versionArray[1] = parseInt(versionArray[1]) + 1;
+      break;
+    case 'patch':
+      versionArray[2] = parseInt(versionArray[2]) + 1;
+      break;
+    default:
+      console.error('Invalid version type');
+      process.exit(1);
+  }
+
+  packageJson.version = versionArray.join('.');
+
+  fs.writeFileSync(pkgPath, JSON.stringify(packageJson, null, 2));
+
+  console.log(`Version update to ${packageJson.version}`);
+
+  try {
+    require('child_process').execSync('npm run deploy', {
+      cwd: __dirname,
+    });
+    console.log(`Publish version ${packageJson.version}`);
+  } catch (error) {
+    console.log('Error on publish >>', error);
+
+    console.log(`Reverting version to previous version ${version}`);
+    packageJson.version = version;
+
+    fs.writeFileSync(pkgPath, JSON.stringify(packageJson, null, 2));
+  }
+})();

package/src/billing/src/__generated__/Billing.ts

@@ -0,0 +1,43 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BaseHttpRequest } from './core/BaseHttpRequest';
+import type { OpenAPIConfig } from './core/OpenAPI';
+import { AxiosHttpRequest } from './core/AxiosHttpRequest';
+import { CardsService } from './services/CardsService';
+import { HealthService } from './services/HealthService';
+import { MerchantsService } from './services/MerchantsService';
+import { PackagesService } from './services/PackagesService';
+import { PaymentsService } from './services/PaymentsService';
+import { SubscriptionsService } from './services/SubscriptionsService';
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+export class Billing {
+    public readonly cards: CardsService;
+    public readonly health: HealthService;
+    public readonly merchants: MerchantsService;
+    public readonly packages: PackagesService;
+    public readonly payments: PaymentsService;
+    public readonly subscriptions: SubscriptionsService;
+    public readonly request: BaseHttpRequest;
+    constructor(config?: Partial<OpenAPIConfig>, HttpRequest: HttpRequestConstructor = AxiosHttpRequest) {
+        this.request = new HttpRequest({
+            BASE: config?.BASE ?? 'http://localhost:3003',
+            VERSION: config?.VERSION ?? '1.0.0',
+            WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+            CREDENTIALS: config?.CREDENTIALS ?? 'include',
+            TOKEN: config?.TOKEN,
+            USERNAME: config?.USERNAME,
+            PASSWORD: config?.PASSWORD,
+            HEADERS: config?.HEADERS,
+            ENCODE_PATH: config?.ENCODE_PATH,
+        });
+        this.cards = new CardsService(this.request);
+        this.health = new HealthService(this.request);
+        this.merchants = new MerchantsService(this.request);
+        this.packages = new PackagesService(this.request);
+        this.payments = new PaymentsService(this.request);
+        this.subscriptions = new SubscriptionsService(this.request);
+    }
+}
+

package/src/billing/src/__generated__/core/ApiError.ts

@@ -0,0 +1,25 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+
+export class ApiError extends Error {
+    public readonly url: string;
+    public readonly status: number;
+    public readonly statusText: string;
+    public readonly body: any;
+    public readonly request: ApiRequestOptions;
+
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
+        super(message);
+
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/src/billing/src/__generated__/core/ApiRequestOptions.ts

@@ -0,0 +1,17 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/src/billing/src/__generated__/core/ApiResult.ts

@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/src/billing/src/__generated__/core/AxiosHttpRequest.ts

@@ -0,0 +1,26 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import { BaseHttpRequest } from './BaseHttpRequest';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+import { request as __request } from './request';
+
+export class AxiosHttpRequest extends BaseHttpRequest {
+
+    constructor(config: OpenAPIConfig) {
+        super(config);
+    }
+
+    /**
+     * Request method
+     * @param options The request options from the service
+     * @returns CancelablePromise<T>
+     * @throws ApiError
+     */
+    public override request<T>(options: ApiRequestOptions): CancelablePromise<T> {
+        return __request(this.config, options);
+    }
+}

package/src/billing/src/__generated__/core/BaseHttpRequest.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+
+export abstract class BaseHttpRequest {
+
+    constructor(public readonly config: OpenAPIConfig) {}
+
+    public abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}