@miguelmorales13/nestkit 0.7.0 → 0.9.0

package/README.md

@@ -535,6 +535,87 @@ contenedor esté listo — no hace falta encadenarlo a mano.
 `forRoot()` sin argumentos toma las credenciales del entorno; pasándoselas explícitas se puede tener
 un proceso publicando en varias cuentas.
 
+### `pinterest` — publicar pines, y por qué no es una red social más
+
+Pinterest es un **buscador visual**, y eso cambia dos cosas frente a Instagram
+y Facebook.
+
+**Cada pin lleva su propio enlace.** Hay un camino directo del contenido al
+sitio, cosa que en Instagram no existe porque el enlace solo vive en la
+biografía.
+
+**El contenido no caduca.** Un pin sigue apareciendo en búsquedas meses después
+de publicarse, mientras que una historia dura 24 horas. Por eso el título y la
+descripción pesan mucho más que un pie de foto en cualquier otro destino: son
+lo que hace que alguien lo encuentre medio año después.
+
+```ts
+import { PinterestModule, PinterestService } from '@miguelmorales13/nestkit/pinterest';
+
+@Module({ imports: [PinterestModule.forRoot()] })   // lee PINTEREST_ACCESS_TOKEN
+export class AppModule {}
+```
+
+```ts
+await pinterest.listBoards();                       // para sacar los ids
+await pinterest.publish({
+  boardId, title, description,
+  link: 'https://tusitio.com/receta',               // esto es lo que importa
+  imageUrl,                                          // Pinterest la descarga él
+});
+```
+
+Igual que Meta, **no acepta el binario**: se le pasa una URL pública y va a
+buscarla. `media` sirve justo para eso.
+
+El servicio se puede usar **suelto, fuera de Nest**: recibe credenciales
+planas y solo usa `fetch`, así que un script de CLI hace
+`new PinterestService({ accessToken })` sin nada de inyección de dependencias.
+Es lo que hace nutrimx, donde quien publica es un script con Playwright y no el
+backend.
+
+El token se saca en developers.pinterest.com con los permisos `boards:read`,
+`pins:read` y `pins:write`. Los títulos se recortan a 100 caracteres y las
+descripciones a 800, que son los límites del API — pasarse devuelve un 400.
+
+### `tiktok` — publicar videos, y el modo que evita la auditoría
+
+Tres llamadas, ninguna opcional: preguntar por la cuenta, inicializar la
+subida y sondear hasta que TikTok termine de procesar. La primera es un
+requisito de sus guías, no una cortesía: la API rechaza publicar si no se
+consultó antes qué admite la cuenta.
+
+```ts
+import { TikTokModule, TikTokService } from '@miguelmorales13/nestkit/tiktok';
+
+@Module({ imports: [TikTokModule.forRoot()] })   // lee TIKTOK_ACCESS_TOKEN
+export class AppModule {}
+```
+
+```ts
+await tiktok.creatorInfo();                       // obligatorio antes de publicar
+const id = await tiktok.publish({ data, title }); // sin privacyLevel: a borradores
+await tiktok.status(id);                          // hasta PUBLISH_COMPLETE
+```
+
+**La diferencia entre los dos modos importa mucho al principio.** En *Direct
+Post* el video sale en vivo, pero exige el permiso `video.publish`, que solo se
+consigue pasando una auditoría de TikTok de varias semanas —y hasta aprobarla
+todo lo publicado queda en `SELF_ONLY`, o sea que no lo ve nadie—. En modo
+**borrador**, que es el de por defecto aquí, el video cae en la bandeja de la
+cuenta y una persona le da publicar desde el teléfono: llega con todo su
+alcance y solo necesita `video.upload`.
+
+Dicho de otro modo: publicar en directo antes de la auditoría es peor que no
+publicar, porque gastas la pieza sin que la vea nadie.
+
+Sube el binario en vez de pasar una URL a propósito. La otra vía,
+`PULL_FROM_URL`, obliga a verificar el dominio en el portal de TikTok, y
+cambiar un trámite por otro no compensa cuando el archivo ya está en disco.
+
+El video tiene que ir en **MP4 H.264**. Límite de **6 peticiones por minuto**
+por token, así que el sondeo del estado va espaciado.
+
 ### `stripe` — cliente de la SDK oficial
 
 ```ts
@@ -979,6 +1060,8 @@ trae los datos.
 | `@miguelmorales13/nestkit/whatsapp` | `WhatsAppModule`, `WHATSAPP_CLIENT`, `WhatsAppClient` |
 | `@miguelmorales13/nestkit/meta` | `MetaModule`, `MetaService` — publicar en Instagram y Facebook Pages |
 | `@miguelmorales13/nestkit/media` | `MediaModule`, `MediaService` — hosting efímero en memoria |
+| `@miguelmorales13/nestkit/pinterest` | `PinterestModule`, `PinterestService` — publicar pines |
+| `@miguelmorales13/nestkit/tiktok` | `TikTokModule`, `TikTokService` — publicar videos |
 | `@miguelmorales13/nestkit/stripe` | `StripeModule`, `STRIPE_CLIENT`, `createStripeWebhookController` |
 | `@miguelmorales13/nestkit/auth` | `AuthUserPort`, `BaseAuthService`, `createAuthController`, `TokenService`, `JwtAuthGuard`, `RolesGuard`, `RequireTenantGuard`, `CurrentUser`, `CurrentTenant`, `Roles` |
 | `@miguelmorales13/nestkit/auth/oauth` | `OAuthAuthModule`, `OAuthAuthService`, `createOAuthController`, `googleProvider`, `facebookProvider`, `OAuthStorePort`, `RefreshTokenStorePort` |
@@ -991,7 +1074,7 @@ trae los datos.
 
 ## Estado del paquete
 
-`0.7.0`. Sin adaptador Mongo real. Sin tests unitarios propios.
+`0.9.0`. Sin adaptador Mongo real. Sin tests unitarios propios.
 
 `auth/oauth` y `umami` sí tienen un consumidor real: **nutrimx** corre su acceso con Google y
 Facebook sobre este módulo en producción. El resto sigue sin ejercitarse de verdad.

package/dist/bootstrap/index.cjs

@@ -1,11 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkYARLPYG5cjs = require('../chunk-YARLPYG5.cjs');
-require('../chunk-J7TURDAL.cjs');
+var _chunk54ZXIB5Tcjs = require('../chunk-54ZXIB5T.cjs');
 require('../chunk-TJHRABML.cjs');
+require('../chunk-J7TURDAL.cjs');
 require('../chunk-ZA56XBCK.cjs');
 require('../chunk-R7BVS6CI.cjs');
 require('../chunk-2REOCMUD.cjs');
 
 
-exports.applyNestKitDefaults = _chunkYARLPYG5cjs.applyNestKitDefaults;
+exports.applyNestKitDefaults = _chunk54ZXIB5Tcjs.applyNestKitDefaults;

package/dist/bootstrap/index.js

@@ -1,8 +1,8 @@
 import {
   applyNestKitDefaults
-} from "../chunk-ANQ3YPDI.js";
-import "../chunk-7I2Y7V52.js";
+} from "../chunk-AOCF5QCZ.js";
 import "../chunk-KDAA6GFF.js";
+import "../chunk-7I2Y7V52.js";
 import "../chunk-EBO6UKHL.js";
 import "../chunk-YFYHLYHN.js";
 import "../chunk-4MGIQFAJ.js";

package/dist/index.cjs

@@ -3,13 +3,12 @@
 
 
 
-var _chunkSPTDXUEDcjs = require('./chunk-SPTDXUED.cjs');
+var _chunkRF75KC63cjs = require('./chunk-RF75KC63.cjs');
 
 
 
 
-var _chunkRF75KC63cjs = require('./chunk-RF75KC63.cjs');
-require('./chunk-7SOM7EZP.cjs');
+var _chunkSPTDXUEDcjs = require('./chunk-SPTDXUED.cjs');
 require('./chunk-MR2IFCZE.cjs');
 
 
@@ -18,30 +17,31 @@ require('./chunk-MR2IFCZE.cjs');
 var _chunkV2M75FN3cjs = require('./chunk-V2M75FN3.cjs');
 
 
+var _chunk54ZXIB5Tcjs = require('./chunk-54ZXIB5T.cjs');
 
 
+var _chunkTJHRABMLcjs = require('./chunk-TJHRABML.cjs');
 
 
-var _chunkFDNGAYTZcjs = require('./chunk-FDNGAYTZ.cjs');
 
+var _chunk3CLYZC3Tcjs = require('./chunk-3CLYZC3T.cjs');
+require('./chunk-7SOM7EZP.cjs');
 
-var _chunkYARLPYG5cjs = require('./chunk-YARLPYG5.cjs');
 
 
-var _chunkJ7TURDALcjs = require('./chunk-J7TURDAL.cjs');
 
 
-var _chunkTJHRABMLcjs = require('./chunk-TJHRABML.cjs');
 
+var _chunkFDNGAYTZcjs = require('./chunk-FDNGAYTZ.cjs');
 
-var _chunkZA56XBCKcjs = require('./chunk-ZA56XBCK.cjs');
 
+var _chunkJ7TURDALcjs = require('./chunk-J7TURDAL.cjs');
 
-var _chunkR7BVS6CIcjs = require('./chunk-R7BVS6CI.cjs');
 
+var _chunkZA56XBCKcjs = require('./chunk-ZA56XBCK.cjs');
 
 
-var _chunk3CLYZC3Tcjs = require('./chunk-3CLYZC3T.cjs');
+var _chunkR7BVS6CIcjs = require('./chunk-R7BVS6CI.cjs');
 
 
 var _chunkQS2W5XCQcjs = require('./chunk-QS2W5XCQ.cjs');
@@ -75,4 +75,4 @@ require('./chunk-2REOCMUD.cjs');
 
 
 
-exports.AppException = _chunkR7BVS6CIcjs.AppException; exports.BaseCrudService = _chunk3CLYZC3Tcjs.BaseCrudService; exports.BaseResponseDto = _chunkQS2W5XCQcjs.BaseResponseDto; exports.ConflictAppException = _chunkFDNGAYTZcjs.ConflictAppException; exports.ForbiddenAppException = _chunkFDNGAYTZcjs.ForbiddenAppException; exports.GlobalExceptionFilter = _chunkJ7TURDALcjs.GlobalExceptionFilter; exports.I18nModule = _chunkM3EL5O6Tcjs.I18nModule; exports.NotFoundAppException = _chunkFDNGAYTZcjs.NotFoundAppException; exports.PG_POOL = _chunkRF75KC63cjs.PG_POOL; exports.PgModule = _chunkRF75KC63cjs.PgModule; exports.REQUEST_ID_HEADER = _chunkV2M75FN3cjs.REQUEST_ID_HEADER; exports.RequestContext = _chunkZA56XBCKcjs.RequestContext; exports.RequestIdMiddleware = _chunkV2M75FN3cjs.RequestIdMiddleware; exports.ResponseInterceptor = _chunkTJHRABMLcjs.ResponseInterceptor; exports.SUPABASE_ANON_CLIENT = _chunkSPTDXUEDcjs.SUPABASE_ANON_CLIENT; exports.SUPABASE_SERVICE_ROLE_CLIENT = _chunkSPTDXUEDcjs.SUPABASE_SERVICE_ROLE_CLIENT; exports.SupabaseModule = _chunkSPTDXUEDcjs.SupabaseModule; exports.TrackingModule = _chunkV2M75FN3cjs.TrackingModule; exports.UnauthorizedAppException = _chunkFDNGAYTZcjs.UnauthorizedAppException; exports.ValidationAppException = _chunkFDNGAYTZcjs.ValidationAppException; exports.applyNestKitDefaults = _chunkYARLPYG5cjs.applyNestKitDefaults; exports.createCrudController = _chunk3CLYZC3Tcjs.createCrudController; exports.translateOr = _chunkM3EL5O6Tcjs.translateOr; exports.withTenantScope = _chunkRF75KC63cjs.withTenantScope;
+exports.AppException = _chunkR7BVS6CIcjs.AppException; exports.BaseCrudService = _chunk3CLYZC3Tcjs.BaseCrudService; exports.BaseResponseDto = _chunkQS2W5XCQcjs.BaseResponseDto; exports.ConflictAppException = _chunkFDNGAYTZcjs.ConflictAppException; exports.ForbiddenAppException = _chunkFDNGAYTZcjs.ForbiddenAppException; exports.GlobalExceptionFilter = _chunkJ7TURDALcjs.GlobalExceptionFilter; exports.I18nModule = _chunkM3EL5O6Tcjs.I18nModule; exports.NotFoundAppException = _chunkFDNGAYTZcjs.NotFoundAppException; exports.PG_POOL = _chunkRF75KC63cjs.PG_POOL; exports.PgModule = _chunkRF75KC63cjs.PgModule; exports.REQUEST_ID_HEADER = _chunkV2M75FN3cjs.REQUEST_ID_HEADER; exports.RequestContext = _chunkZA56XBCKcjs.RequestContext; exports.RequestIdMiddleware = _chunkV2M75FN3cjs.RequestIdMiddleware; exports.ResponseInterceptor = _chunkTJHRABMLcjs.ResponseInterceptor; exports.SUPABASE_ANON_CLIENT = _chunkSPTDXUEDcjs.SUPABASE_ANON_CLIENT; exports.SUPABASE_SERVICE_ROLE_CLIENT = _chunkSPTDXUEDcjs.SUPABASE_SERVICE_ROLE_CLIENT; exports.SupabaseModule = _chunkSPTDXUEDcjs.SupabaseModule; exports.TrackingModule = _chunkV2M75FN3cjs.TrackingModule; exports.UnauthorizedAppException = _chunkFDNGAYTZcjs.UnauthorizedAppException; exports.ValidationAppException = _chunkFDNGAYTZcjs.ValidationAppException; exports.applyNestKitDefaults = _chunk54ZXIB5Tcjs.applyNestKitDefaults; exports.createCrudController = _chunk3CLYZC3Tcjs.createCrudController; exports.translateOr = _chunkM3EL5O6Tcjs.translateOr; exports.withTenantScope = _chunkRF75KC63cjs.withTenantScope;

package/dist/index.js

@@ -1,21 +1,31 @@
 import "./chunk-EPVKCBPT.js";
-import {
-  SUPABASE_ANON_CLIENT,
-  SUPABASE_SERVICE_ROLE_CLIENT,
-  SupabaseModule
-} from "./chunk-PA24P76K.js";
 import {
   PG_POOL,
   PgModule,
   withTenantScope
 } from "./chunk-VKOPDDCC.js";
-import "./chunk-DQYAIQQ5.js";
+import {
+  SUPABASE_ANON_CLIENT,
+  SUPABASE_SERVICE_ROLE_CLIENT,
+  SupabaseModule
+} from "./chunk-PA24P76K.js";
 import "./chunk-NAK4WDKS.js";
 import {
   REQUEST_ID_HEADER,
   RequestIdMiddleware,
   TrackingModule
 } from "./chunk-EYURGACO.js";
+import {
+  applyNestKitDefaults
+} from "./chunk-AOCF5QCZ.js";
+import {
+  ResponseInterceptor
+} from "./chunk-KDAA6GFF.js";
+import {
+  BaseCrudService,
+  createCrudController
+} from "./chunk-JOVBJDJ2.js";
+import "./chunk-DQYAIQQ5.js";
 import {
   ConflictAppException,
   ForbiddenAppException,
@@ -23,25 +33,15 @@ import {
   UnauthorizedAppException,
   ValidationAppException
 } from "./chunk-ORWJ7LES.js";
-import {
-  applyNestKitDefaults
-} from "./chunk-ANQ3YPDI.js";
 import {
   GlobalExceptionFilter
 } from "./chunk-7I2Y7V52.js";
-import {
-  ResponseInterceptor
-} from "./chunk-KDAA6GFF.js";
 import {
   RequestContext
 } from "./chunk-EBO6UKHL.js";
 import {
   AppException
 } from "./chunk-YFYHLYHN.js";
-import {
-  BaseCrudService,
-  createCrudController
-} from "./chunk-JOVBJDJ2.js";
 import {
   BaseResponseDto
 } from "./chunk-XX2HPTRU.js";

package/dist/pinterest/index.cjs

@@ -0,0 +1,101 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunk2REOCMUDcjs = require('../chunk-2REOCMUD.cjs');
+
+// src/pinterest/pinterest.service.ts
+var _common = require('@nestjs/common');
+var API = "https://api.pinterest.com/v5";
+var MAX_TITLE = 100;
+var MAX_DESCRIPTION = 800;
+var PinterestService = class {
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  /** The account's boards. Used to resolve the ids that configuration needs. */
+  async listBoards() {
+    const data = await this.request("/boards?page_size=50");
+    return _nullishCoalesce(data.items, () => ( []));
+  }
+  /** Creates a pin and returns its id. */
+  async publish(pin) {
+    const created = await this.request("/pins", {
+      method: "POST",
+      body: {
+        board_id: pin.boardId,
+        title: pin.title.slice(0, MAX_TITLE),
+        description: pin.description.slice(0, MAX_DESCRIPTION),
+        link: pin.link,
+        media_source: { source_type: "image_url", url: pin.imageUrl }
+      }
+    });
+    return created.id;
+  }
+  /** Whether there is a token at all. */
+  get configured() {
+    return Boolean(this.credentials.accessToken);
+  }
+  async request(path, options = {}) {
+    if (!this.credentials.accessToken) {
+      throw new Error("PinterestService: no access token configured");
+    }
+    const response = await fetch(`${API}${path}`, {
+      method: _nullishCoalesce(options.method, () => ( "GET")),
+      headers: {
+        Authorization: `Bearer ${this.credentials.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      ...options.body ? { body: JSON.stringify(options.body) } : {}
+    });
+    const text = await response.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch (e) {
+      throw new Error(`Pinterest answered ${response.status} with non-JSON: ${text.slice(0, 200)}`);
+    }
+    if (!response.ok) {
+      const error = data;
+      throw new Error(
+        `Pinterest answered ${response.status}: ${_nullishCoalesce(error.message, () => ( text.slice(0, 200)))}`
+      );
+    }
+    return data;
+  }
+};
+PinterestService = exports.PinterestService = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Injectable.call(void 0, )
+], PinterestService);
+
+// src/pinterest/pinterest.module.ts
+
+var PinterestModule = class {
+  static forRoot(credentials) {
+    return {
+      module: PinterestModule,
+      providers: [
+        {
+          provide: PinterestService,
+          useFactory: () => {
+            const resolved = _nullishCoalesce(credentials, () => ( {
+              accessToken: _nullishCoalesce(process.env.PINTEREST_ACCESS_TOKEN, () => ( ""))
+            }));
+            if (!resolved.accessToken) {
+              throw new Error(
+                "PinterestModule: no access token. Set PINTEREST_ACCESS_TOKEN or pass credentials to forRoot()."
+              );
+            }
+            return new PinterestService(resolved);
+          }
+        }
+      ],
+      exports: [PinterestService]
+    };
+  }
+};
+PinterestModule = exports.PinterestModule = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Module.call(void 0, {})
+], PinterestModule);
+
+
+
+exports.PinterestModule = PinterestModule; exports.PinterestService = PinterestService;

package/dist/pinterest/index.d.ts

@@ -0,0 +1,3 @@
+export { PinterestService } from './pinterest.service.js';
+export type { PinterestCredentials, PinterestBoard, NewPin, } from './pinterest.service.js';
+export { PinterestModule } from './pinterest.module.js';

package/dist/pinterest/index.js

@@ -0,0 +1,101 @@
+import {
+  __decorateClass
+} from "../chunk-4MGIQFAJ.js";
+
+// src/pinterest/pinterest.service.ts
+import { Injectable } from "@nestjs/common";
+var API = "https://api.pinterest.com/v5";
+var MAX_TITLE = 100;
+var MAX_DESCRIPTION = 800;
+var PinterestService = class {
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  /** The account's boards. Used to resolve the ids that configuration needs. */
+  async listBoards() {
+    const data = await this.request("/boards?page_size=50");
+    return data.items ?? [];
+  }
+  /** Creates a pin and returns its id. */
+  async publish(pin) {
+    const created = await this.request("/pins", {
+      method: "POST",
+      body: {
+        board_id: pin.boardId,
+        title: pin.title.slice(0, MAX_TITLE),
+        description: pin.description.slice(0, MAX_DESCRIPTION),
+        link: pin.link,
+        media_source: { source_type: "image_url", url: pin.imageUrl }
+      }
+    });
+    return created.id;
+  }
+  /** Whether there is a token at all. */
+  get configured() {
+    return Boolean(this.credentials.accessToken);
+  }
+  async request(path, options = {}) {
+    if (!this.credentials.accessToken) {
+      throw new Error("PinterestService: no access token configured");
+    }
+    const response = await fetch(`${API}${path}`, {
+      method: options.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${this.credentials.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      ...options.body ? { body: JSON.stringify(options.body) } : {}
+    });
+    const text = await response.text();
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(`Pinterest answered ${response.status} with non-JSON: ${text.slice(0, 200)}`);
+    }
+    if (!response.ok) {
+      const error = data;
+      throw new Error(
+        `Pinterest answered ${response.status}: ${error.message ?? text.slice(0, 200)}`
+      );
+    }
+    return data;
+  }
+};
+PinterestService = __decorateClass([
+  Injectable()
+], PinterestService);
+
+// src/pinterest/pinterest.module.ts
+import { Module } from "@nestjs/common";
+var PinterestModule = class {
+  static forRoot(credentials) {
+    return {
+      module: PinterestModule,
+      providers: [
+        {
+          provide: PinterestService,
+          useFactory: () => {
+            const resolved = credentials ?? {
+              accessToken: process.env.PINTEREST_ACCESS_TOKEN ?? ""
+            };
+            if (!resolved.accessToken) {
+              throw new Error(
+                "PinterestModule: no access token. Set PINTEREST_ACCESS_TOKEN or pass credentials to forRoot()."
+              );
+            }
+            return new PinterestService(resolved);
+          }
+        }
+      ],
+      exports: [PinterestService]
+    };
+  }
+};
+PinterestModule = __decorateClass([
+  Module({})
+], PinterestModule);
+export {
+  PinterestModule,
+  PinterestService
+};

package/dist/pinterest/pinterest.module.d.ts

@@ -0,0 +1,16 @@
+import { type DynamicModule } from '@nestjs/common';
+import { type PinterestCredentials } from './pinterest.service.js';
+/**
+ * Outbound client for Pinterest. See `PinterestService`.
+ *
+ * Credentials come from `PINTEREST_ACCESS_TOKEN` by default, or are passed
+ * explicitly to `forRoot` — which is what a process publishing to several
+ * accounts needs.
+ *
+ * Unlike most modules here, the service is also useful on its own: it takes
+ * plain credentials and uses nothing but `fetch`, so a script outside Nest can
+ * do `new PinterestService({ accessToken })` without any of the DI machinery.
+ */
+export declare class PinterestModule {
+    static forRoot(credentials?: PinterestCredentials): DynamicModule;
+}

package/dist/pinterest/pinterest.service.d.ts

@@ -0,0 +1,51 @@
+export interface PinterestCredentials {
+    /** Token from developers.pinterest.com with boards:read, pins:read, pins:write. */
+    accessToken: string;
+}
+export interface PinterestBoard {
+    id: string;
+    name: string;
+}
+export interface NewPin {
+    boardId: string;
+    /** What people read in search results. Trimmed to 100 characters. */
+    title: string;
+    /** The long text carrying the words you want to be found by. */
+    description: string;
+    /** Where the pin leads when tapped. This is the whole point of Pinterest. */
+    link: string;
+    /** Publicly reachable image URL — Pinterest downloads it when creating the pin. */
+    imageUrl: string;
+}
+/**
+ * Publishes pins through the Pinterest API v5.
+ *
+ * Pinterest is not one more social network: it is a visual search engine, and
+ * that changes two things about how content behaves there.
+ *
+ * **Every pin carries its own link.** So there is a direct path from a piece of
+ * content to a site — unlike Instagram, where a link only lives in the bio.
+ *
+ * **The content does not expire.** A pin keeps surfacing in searches months
+ * after it was published, while a story lasts a day. That makes the title and
+ * description matter far more than a caption elsewhere: they are what makes
+ * someone find the pin half a year later.
+ *
+ * Like Meta's API, Pinterest does not take the binary — it is given a public
+ * URL and fetches the image itself, so the caller needs somewhere to serve it
+ * from during publication. `MediaModule` in this same package exists for that.
+ *
+ * Send-only, like `TelegramModule` and `MetaModule`: it publishes and lists
+ * boards, it does not read analytics or manage comments.
+ */
+export declare class PinterestService {
+    private readonly credentials;
+    constructor(credentials: PinterestCredentials);
+    /** The account's boards. Used to resolve the ids that configuration needs. */
+    listBoards(): Promise<PinterestBoard[]>;
+    /** Creates a pin and returns its id. */
+    publish(pin: NewPin): Promise<string>;
+    /** Whether there is a token at all. */
+    get configured(): boolean;
+    private request;
+}

package/dist/tiktok/index.cjs

@@ -0,0 +1,142 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunk2REOCMUDcjs = require('../chunk-2REOCMUD.cjs');
+
+// src/tiktok/tiktok.service.ts
+var _common = require('@nestjs/common');
+var API = "https://open.tiktokapis.com/v2";
+var TikTokService = class {
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  get configured() {
+    return Boolean(this.credentials.accessToken);
+  }
+  /**
+   * Datos de la cuenta. Hay que llamarlo antes de publicar: TikTok lo exige
+   * y además dice qué niveles de privacidad admite, que varían según si la
+   * cuenta es privada, de empresa o de menor de edad.
+   */
+  async creatorInfo() {
+    return this.request("/post/publish/creator_info/query/", {});
+  }
+  /**
+   * Sube un vídeo y devuelve el `publish_id` con el que seguir su estado.
+   *
+   * Sin `privacyLevel` va a borradores; con él, se publica directo —y para eso
+   * hace falta que la aplicación haya pasado la auditoría.
+   */
+  async publish(video) {
+    const directo = Boolean(video.privacyLevel);
+    const ruta = directo ? "/post/publish/video/init/" : "/post/publish/inbox/video/init/";
+    const cuerpo = {
+      source_info: {
+        source: "FILE_UPLOAD",
+        video_size: video.data.byteLength,
+        // Una sola parte: estos clips son de unos pocos megas y trocearlos
+        // solo añadiría puntos donde fallar.
+        chunk_size: video.data.byteLength,
+        total_chunk_count: 1
+      }
+    };
+    if (directo) {
+      cuerpo.post_info = {
+        title: video.title.slice(0, 2200),
+        privacy_level: video.privacyLevel
+      };
+    }
+    const inicio = await this.request(
+      ruta,
+      cuerpo
+    );
+    const subida = await fetch(inicio.upload_url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "video/mp4",
+        // TikTok exige el rango incluso subiendo el archivo entero de una vez.
+        "Content-Range": `bytes 0-${video.data.byteLength - 1}/${video.data.byteLength}`
+      },
+      body: new Uint8Array(video.data)
+    });
+    if (!subida.ok) {
+      throw new Error(
+        `TikTok rechaz\xF3 el archivo (HTTP ${subida.status}): ${(await subida.text()).slice(0, 200)}`
+      );
+    }
+    return inicio.publish_id;
+  }
+  /** En qué va el procesado. Termina en `PUBLISH_COMPLETE` o en un fallo. */
+  async status(publishId) {
+    return this.request(
+      "/post/publish/status/fetch/",
+      { publish_id: publishId }
+    );
+  }
+  async request(path, body) {
+    if (!this.credentials.accessToken) {
+      throw new Error("TikTokService: no access token configured");
+    }
+    const response = await fetch(`${API}${path}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.credentials.accessToken}`,
+        "Content-Type": "application/json; charset=UTF-8"
+      },
+      body: JSON.stringify(body)
+    });
+    const text = await response.text();
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (e) {
+      throw new Error(`TikTok respondi\xF3 ${response.status} y no era JSON: ${text.slice(0, 200)}`);
+    }
+    if (json.error && json.error.code && json.error.code !== "ok") {
+      throw new Error(`TikTok: ${json.error.code} \u2014 ${_nullishCoalesce(json.error.message, () => ( ""))}`.trim());
+    }
+    if (!response.ok) {
+      throw new Error(`TikTok respondi\xF3 HTTP ${response.status}: ${text.slice(0, 200)}`);
+    }
+    if (!json.data) {
+      throw new Error(`TikTok devolvi\xF3 una respuesta sin datos: ${text.slice(0, 200)}`);
+    }
+    return json.data;
+  }
+};
+TikTokService = exports.TikTokService = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Injectable.call(void 0, )
+], TikTokService);
+
+// src/tiktok/tiktok.module.ts
+
+var TikTokModule = class {
+  static forRoot(credentials) {
+    return {
+      module: TikTokModule,
+      providers: [
+        {
+          provide: TikTokService,
+          useFactory: () => {
+            const resolved = _nullishCoalesce(credentials, () => ( {
+              accessToken: _nullishCoalesce(process.env.TIKTOK_ACCESS_TOKEN, () => ( ""))
+            }));
+            if (!resolved.accessToken) {
+              throw new Error(
+                "TikTokModule: no access token. Set TIKTOK_ACCESS_TOKEN or pass credentials to forRoot()."
+              );
+            }
+            return new TikTokService(resolved);
+          }
+        }
+      ],
+      exports: [TikTokService]
+    };
+  }
+};
+TikTokModule = exports.TikTokModule = _chunk2REOCMUDcjs.__decorateClass.call(void 0, [
+  _common.Module.call(void 0, {})
+], TikTokModule);
+
+
+
+exports.TikTokModule = TikTokModule; exports.TikTokService = TikTokService;

package/dist/tiktok/index.d.ts

@@ -0,0 +1,3 @@
+export { TikTokService } from './tiktok.service.js';
+export type { TikTokCredentials, TikTokCreatorInfo, TikTokVideo, } from './tiktok.service.js';
+export { TikTokModule } from './tiktok.module.js';

package/dist/tiktok/index.js

@@ -0,0 +1,142 @@
+import {
+  __decorateClass
+} from "../chunk-4MGIQFAJ.js";
+
+// src/tiktok/tiktok.service.ts
+import { Injectable } from "@nestjs/common";
+var API = "https://open.tiktokapis.com/v2";
+var TikTokService = class {
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  get configured() {
+    return Boolean(this.credentials.accessToken);
+  }
+  /**
+   * Datos de la cuenta. Hay que llamarlo antes de publicar: TikTok lo exige
+   * y además dice qué niveles de privacidad admite, que varían según si la
+   * cuenta es privada, de empresa o de menor de edad.
+   */
+  async creatorInfo() {
+    return this.request("/post/publish/creator_info/query/", {});
+  }
+  /**
+   * Sube un vídeo y devuelve el `publish_id` con el que seguir su estado.
+   *
+   * Sin `privacyLevel` va a borradores; con él, se publica directo —y para eso
+   * hace falta que la aplicación haya pasado la auditoría.
+   */
+  async publish(video) {
+    const directo = Boolean(video.privacyLevel);
+    const ruta = directo ? "/post/publish/video/init/" : "/post/publish/inbox/video/init/";
+    const cuerpo = {
+      source_info: {
+        source: "FILE_UPLOAD",
+        video_size: video.data.byteLength,
+        // Una sola parte: estos clips son de unos pocos megas y trocearlos
+        // solo añadiría puntos donde fallar.
+        chunk_size: video.data.byteLength,
+        total_chunk_count: 1
+      }
+    };
+    if (directo) {
+      cuerpo.post_info = {
+        title: video.title.slice(0, 2200),
+        privacy_level: video.privacyLevel
+      };
+    }
+    const inicio = await this.request(
+      ruta,
+      cuerpo
+    );
+    const subida = await fetch(inicio.upload_url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "video/mp4",
+        // TikTok exige el rango incluso subiendo el archivo entero de una vez.
+        "Content-Range": `bytes 0-${video.data.byteLength - 1}/${video.data.byteLength}`
+      },
+      body: new Uint8Array(video.data)
+    });
+    if (!subida.ok) {
+      throw new Error(
+        `TikTok rechaz\xF3 el archivo (HTTP ${subida.status}): ${(await subida.text()).slice(0, 200)}`
+      );
+    }
+    return inicio.publish_id;
+  }
+  /** En qué va el procesado. Termina en `PUBLISH_COMPLETE` o en un fallo. */
+  async status(publishId) {
+    return this.request(
+      "/post/publish/status/fetch/",
+      { publish_id: publishId }
+    );
+  }
+  async request(path, body) {
+    if (!this.credentials.accessToken) {
+      throw new Error("TikTokService: no access token configured");
+    }
+    const response = await fetch(`${API}${path}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.credentials.accessToken}`,
+        "Content-Type": "application/json; charset=UTF-8"
+      },
+      body: JSON.stringify(body)
+    });
+    const text = await response.text();
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new Error(`TikTok respondi\xF3 ${response.status} y no era JSON: ${text.slice(0, 200)}`);
+    }
+    if (json.error && json.error.code && json.error.code !== "ok") {
+      throw new Error(`TikTok: ${json.error.code} \u2014 ${json.error.message ?? ""}`.trim());
+    }
+    if (!response.ok) {
+      throw new Error(`TikTok respondi\xF3 HTTP ${response.status}: ${text.slice(0, 200)}`);
+    }
+    if (!json.data) {
+      throw new Error(`TikTok devolvi\xF3 una respuesta sin datos: ${text.slice(0, 200)}`);
+    }
+    return json.data;
+  }
+};
+TikTokService = __decorateClass([
+  Injectable()
+], TikTokService);
+
+// src/tiktok/tiktok.module.ts
+import { Module } from "@nestjs/common";
+var TikTokModule = class {
+  static forRoot(credentials) {
+    return {
+      module: TikTokModule,
+      providers: [
+        {
+          provide: TikTokService,
+          useFactory: () => {
+            const resolved = credentials ?? {
+              accessToken: process.env.TIKTOK_ACCESS_TOKEN ?? ""
+            };
+            if (!resolved.accessToken) {
+              throw new Error(
+                "TikTokModule: no access token. Set TIKTOK_ACCESS_TOKEN or pass credentials to forRoot()."
+              );
+            }
+            return new TikTokService(resolved);
+          }
+        }
+      ],
+      exports: [TikTokService]
+    };
+  }
+};
+TikTokModule = __decorateClass([
+  Module({})
+], TikTokModule);
+export {
+  TikTokModule,
+  TikTokService
+};

package/dist/tiktok/tiktok.module.d.ts

@@ -0,0 +1,13 @@
+import { type DynamicModule } from '@nestjs/common';
+import { type TikTokCredentials } from './tiktok.service.js';
+/**
+ * Outbound client for TikTok's Content Posting API. See `TikTokService`.
+ *
+ * Reads `TIKTOK_ACCESS_TOKEN` by default. Like `PinterestService`, the service
+ * takes plain credentials and uses nothing but `fetch`, so a script outside
+ * Nest can do `new TikTokService({ accessToken })` — which is what the caller
+ * holding the rendered video usually is.
+ */
+export declare class TikTokModule {
+    static forRoot(credentials?: TikTokCredentials): DynamicModule;
+}

package/dist/tiktok/tiktok.service.d.ts

@@ -0,0 +1,75 @@
+export interface TikTokCredentials {
+    /** Token de usuario con `video.upload` o `video.publish`. */
+    accessToken: string;
+}
+/** Lo que TikTok cuenta de la cuenta antes de dejar publicar. */
+export interface TikTokCreatorInfo {
+    creator_username: string;
+    creator_nickname: string;
+    /** Niveles de privacidad que la cuenta admite. Ver `publish`. */
+    privacy_level_options: string[];
+    max_video_post_duration_sec: number;
+}
+export interface TikTokVideo {
+    /** El vídeo, ya en MP4 H.264. */
+    data: Buffer;
+    /** El texto del post. Hasta 2200 caracteres. */
+    title: string;
+    /**
+     * Cómo queda publicado. Si se omite, va a **borradores**: aparece en la
+     * bandeja de TikTok de la cuenta y una persona le da publicar.
+     *
+     * Ese es el modo que conviene mientras la aplicación no haya pasado la
+     * auditoría de TikTok, porque el modo directo publica en `SELF_ONLY` hasta
+     * entonces —es decir, no lo ve nadie— mientras que el borrador llega igual
+     * y se publica a mano sin perder alcance.
+     */
+    privacyLevel?: string;
+}
+/**
+ * Publica vídeos con la Content Posting API de TikTok.
+ *
+ * El flujo son tres llamadas y ninguna es opcional: preguntar por la cuenta,
+ * inicializar la subida, y sondear hasta que TikTok termine de procesar. La
+ * primera es un requisito de sus guías —no una cortesía—: la API rechaza
+ * publicar sin haber consultado antes qué admite la cuenta.
+ *
+ * **Dos modos, y la diferencia importa mucho al principio.** En *Direct Post*
+ * el vídeo sale en vivo, pero exige el permiso `video.publish`, que solo se
+ * consigue pasando una auditoría de TikTok de varias semanas; hasta aprobarla
+ * todo lo publicado queda en `SELF_ONLY` y no lo ve nadie. En modo *borrador*
+ * —el de por defecto aquí— el vídeo cae en la bandeja de la cuenta y una
+ * persona le da publicar desde el teléfono: llega con todo su alcance y solo
+ * necesita `video.upload`.
+ *
+ * Se sube el binario en vez de pasar una URL a propósito. La otra vía,
+ * `PULL_FROM_URL`, obliga a verificar el dominio en el portal de TikTok, y
+ * cambiar un trámite por otro no compensa cuando el archivo ya está en disco.
+ *
+ * El límite es de 6 peticiones por minuto y por token, así que el sondeo del
+ * estado va espaciado.
+ */
+export declare class TikTokService {
+    private readonly credentials;
+    constructor(credentials: TikTokCredentials);
+    get configured(): boolean;
+    /**
+     * Datos de la cuenta. Hay que llamarlo antes de publicar: TikTok lo exige
+     * y además dice qué niveles de privacidad admite, que varían según si la
+     * cuenta es privada, de empresa o de menor de edad.
+     */
+    creatorInfo(): Promise<TikTokCreatorInfo>;
+    /**
+     * Sube un vídeo y devuelve el `publish_id` con el que seguir su estado.
+     *
+     * Sin `privacyLevel` va a borradores; con él, se publica directo —y para eso
+     * hace falta que la aplicación haya pasado la auditoría.
+     */
+    publish(video: TikTokVideo): Promise<string>;
+    /** En qué va el procesado. Termina en `PUBLISH_COMPLETE` o en un fallo. */
+    status(publishId: string): Promise<{
+        status: string;
+        fail_reason?: string;
+    }>;
+    private request;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miguelmorales13/nestkit",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -116,6 +116,16 @@
       "import": "./dist/meta/index.js",
       "require": "./dist/meta/index.cjs"
     },
+    "./pinterest": {
+      "types": "./dist/pinterest/index.d.ts",
+      "import": "./dist/pinterest/index.js",
+      "require": "./dist/pinterest/index.cjs"
+    },
+    "./tiktok": {
+      "types": "./dist/tiktok/index.d.ts",
+      "import": "./dist/tiktok/index.js",
+      "require": "./dist/tiktok/index.cjs"
+    },
     "./media": {
       "types": "./dist/media/index.d.ts",
       "import": "./dist/media/index.js",

package/dist/{chunk-YARLPYG5.cjs → chunk-54ZXIB5T.cjs}

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkJ7TURDALcjs = require('./chunk-J7TURDAL.cjs');
+var _chunkTJHRABMLcjs = require('./chunk-TJHRABML.cjs');
 
 
-var _chunkTJHRABMLcjs = require('./chunk-TJHRABML.cjs');
+var _chunkJ7TURDALcjs = require('./chunk-J7TURDAL.cjs');
 
 // src/bootstrap/apply-defaults.ts
 

package/dist/{chunk-ANQ3YPDI.js → chunk-AOCF5QCZ.js}

@@ -1,9 +1,9 @@
-import {
-  GlobalExceptionFilter
-} from "./chunk-7I2Y7V52.js";
 import {
   ResponseInterceptor
 } from "./chunk-KDAA6GFF.js";
+import {
+  GlobalExceptionFilter
+} from "./chunk-7I2Y7V52.js";
 
 // src/bootstrap/apply-defaults.ts
 import {