shori-sdk-ts 1.0.1

package/src/modules/caso/filter/secondaryLevelFilter.ts

@@ -0,0 +1,271 @@
+import { z } from "zod";
+import { FilterOperator } from "./filterOperator.js";
+import { SortDirection } from "./sortDirection.js";
+
+// ── Schema de validación Zod ──────────────────────────────────────────────────
+
+export const SecondaryLevelFilterSchema = z.object({
+  secondaryLevelId: z.string().optional(),
+  name: z.string().optional(),
+  systemName: z.string().optional(),
+  responsibleId: z.string().optional(),
+  active: z.string().optional(),
+  primaryLevelId: z.string().optional(),
+  primaryLevelName: z.string().optional(),
+  primaryLevelSystemName: z.string().optional(),
+  caseTypeCount: z.string().optional(),
+  pagination: z.object({
+    pageNumber: z.number().int().min(0).default(0),
+    pageSize: z.number().int().min(1).max(200).default(20),
+    orderBy: z.string().default("name"),
+    sortDirection: z.nativeEnum(SortDirection).default(SortDirection.DESC),
+  }),
+});
+
+export type SecondaryLevelFilterData = z.infer<
+  typeof SecondaryLevelFilterSchema
+>;
+
+// ── Clase principal ───────────────────────────────────────────────────────────
+
+/**
+ * Resultado de `SecondaryLevelFilter.builder().build()` — objeto inmutable.
+ *
+ * Los campos son `readonly` y públicos: `JSON.stringify` los serializa
+ * directamente sin necesitar `toJSON()`.
+ *
+ * Se usa con `client.caso().secondaryLevel().search(filter)`.
+ *
+ * @example
+ * ```ts
+ * const filter = SecondaryLevelFilter.builder()
+ *   .name(FilterOperator.LIKE, "Atención")
+ *   .primaryLevelName(FilterOperator.EQ, "Casos")
+ *   .active(FilterOperator.EQ, "true")
+ *   .build();
+ *
+ * // IN implícito
+ * const filter = SecondaryLevelFilter.builder()
+ *   .secondaryLevelId("uuid-1", "uuid-2")
+ *   .primaryLevelId("prim-100")
+ *   .build();
+ * ```
+ */
+export class SecondaryLevelFilter {
+  readonly secondaryLevelId?: string;
+  readonly name?: string;
+  readonly systemName?: string;
+  readonly responsibleId?: string;
+  readonly active?: string;
+  readonly primaryLevelId?: string;
+  readonly primaryLevelName?: string;
+  readonly primaryLevelSystemName?: string;
+  readonly caseTypeCount?: string;
+  readonly pagination: {
+    pageNumber: number;
+    pageSize: number;
+    orderBy: string;
+    sortDirection: SortDirection;
+  };
+
+  private constructor(data: SecondaryLevelFilterData) {
+    this.secondaryLevelId = data.secondaryLevelId;
+    this.name = data.name;
+    this.systemName = data.systemName;
+    this.responsibleId = data.responsibleId;
+    this.active = data.active;
+    this.primaryLevelId = data.primaryLevelId;
+    this.primaryLevelName = data.primaryLevelName;
+    this.primaryLevelSystemName = data.primaryLevelSystemName;
+    this.caseTypeCount = data.caseTypeCount;
+    this.pagination = data.pagination;
+  }
+
+  static builder(): _SecondaryLevelFilterBuilder {
+    return new _SecondaryLevelFilterBuilder();
+  }
+
+  static _create(data: SecondaryLevelFilterData): SecondaryLevelFilter {
+    return new SecondaryLevelFilter(data);
+  }
+
+  /** @internal */
+  getPageNumber(): number {
+    return this.pagination.pageNumber;
+  }
+  /** @internal */
+  getPageSize(): number {
+    return this.pagination.pageSize;
+  }
+
+  /** @internal */
+  copyForNextPage(): SecondaryLevelFilter {
+    return SecondaryLevelFilter._create({
+      ...this,
+      pagination: {
+        ...this.pagination,
+        pageNumber: this.pagination.pageNumber + 1,
+      },
+    });
+  }
+}
+
+// ── Builder ───────────────────────────────────────────────────────────────────
+
+/**
+ * Builder fluido para `SecondaryLevelFilter`.
+ * Obtén una instancia con `SecondaryLevelFilter.builder()`.
+ */
+export class _SecondaryLevelFilterBuilder {
+  private _secondaryLevelId?: string;
+  private _name?: string;
+  private _systemName?: string;
+  private _responsibleId?: string;
+  private _active?: string;
+  private _primaryLevelId?: string;
+  private _primaryLevelName?: string;
+  private _primaryLevelSystemName?: string;
+  private _caseTypeCount?: string;
+  private _pageNumber?: number;
+  private _pageSize?: number;
+  private _orderBy?: string;
+  private _sortDir?: SortDirection;
+
+  secondaryLevelId(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._secondaryLevelId =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  name(operatorOrValue: FilterOperator | string, ...values: string[]): this {
+    this._name =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  systemName(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._systemName =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  responsibleId(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._responsibleId =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  active(operatorOrValue: FilterOperator | string, ...values: string[]): this {
+    this._active =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  primaryLevelId(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._primaryLevelId =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  primaryLevelName(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._primaryLevelName =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  primaryLevelSystemName(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._primaryLevelSystemName =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  caseTypeCount(
+    operatorOrValue: FilterOperator | string,
+    ...values: string[]
+  ): this {
+    this._caseTypeCount =
+      operatorOrValue instanceof FilterOperator
+        ? operatorOrValue.apply(...values)
+        : FilterOperator.IN.apply(operatorOrValue, ...values);
+    return this;
+  }
+
+  pageNumber(n: number): this {
+    this._pageNumber = n;
+    return this;
+  }
+  pageSize(size: number): this {
+    this._pageSize = size;
+    return this;
+  }
+  orderBy(field: string): this {
+    this._orderBy = field;
+    return this;
+  }
+  sortDirection(dir: SortDirection): this {
+    this._sortDir = dir;
+    return this;
+  }
+
+  /**
+   * Aplica operadores implícitos, valida con Zod y retorna `SecondaryLevelFilter` inmutable.
+   * @throws {z.ZodError} si la paginación es inválida
+   */
+  build(): SecondaryLevelFilter {
+    const applyIn = (v?: string) =>
+      v && !FilterOperator.hasOperator(v) ? `in:${v}` : v;
+
+    const data = SecondaryLevelFilterSchema.parse({
+      secondaryLevelId: applyIn(this._secondaryLevelId),
+      name: applyIn(this._name),
+      systemName: applyIn(this._systemName),
+      responsibleId: applyIn(this._responsibleId),
+      active: applyIn(this._active),
+      primaryLevelId: applyIn(this._primaryLevelId),
+      primaryLevelName: applyIn(this._primaryLevelName),
+      primaryLevelSystemName: applyIn(this._primaryLevelSystemName),
+      caseTypeCount: applyIn(this._caseTypeCount),
+      pagination: {
+        pageNumber: this._pageNumber,
+        pageSize: this._pageSize,
+        orderBy: this._orderBy,
+        sortDirection: this._sortDir,
+      },
+    });
+    return SecondaryLevelFilter._create(data);
+  }
+}

package/src/modules/caso/filter/sortDirection.ts

@@ -0,0 +1,5 @@
+/** Dirección de ordenamiento para búsquedas */
+export enum SortDirection {
+  ASC = "asc",
+  DESC = "desc",
+}

package/src/modules/repo/dto/downloadRequests.ts

@@ -0,0 +1,45 @@
+/**
+ * Parámetros para descargar un documento por su UUID.
+ *
+ * @example
+ * ```ts
+ * const file = await client.repo().download().byDocument({
+ *   documentId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+ *   fileName: "contrato.pdf",
+ * });
+ * console.log(file.name); // "contrato.pdf"
+ * ```
+ */
+export interface GetDocumentByIdRequest {
+  /** UUID del documento a descargar */
+  documentId: string;
+  /**
+   * Nombre del archivo resultado.
+   * Si no se especifica, se usa `"document"` por defecto.
+   */
+  fileName?: string;
+}
+
+/**
+ * Parámetros para descargar una versión específica de un documento.
+ *
+ * @example
+ * ```ts
+ * const file = await client.repo().download().byDocumentAndVersion({
+ *   documentId: "doc-uuid",
+ *   versionId: "version-uuid",
+ *   fileName: "contrato-v2.pdf",
+ * });
+ * ```
+ */
+export interface DownloadByDocumentAndVersionRequest {
+  /** UUID del documento */
+  documentId: string;
+  /** UUID de la versión específica */
+  versionId: string;
+  /**
+   * Nombre del archivo resultado.
+   * Si no se especifica, se usa `"document"` por defecto.
+   */
+  fileName?: string;
+}

package/src/modules/repo/dto/uploadDocumentRequest.ts

@@ -0,0 +1,43 @@
+/**
+ * Parámetros para subir un documento al repositorio de Shori.
+ *
+ * @example
+ * ```ts
+ * // Con un File del navegador (input type="file")
+ * const request: UploadDocumentRequest = {
+ *   file: fileInput.files[0],
+ *   casoId: "caso-uuid",
+ *   casoTypeId: "tipo-uuid",
+ *   isValid: false,
+ *   isDeleted: false,
+ *   encrypted: false,
+ * };
+ *
+ * // Con un Blob generado dinámicamente
+ * const blob = new Blob([pdfBytes], { type: "application/pdf" });
+ * const request: UploadDocumentRequest = {
+ *   file: blob,
+ *   fileName: "contrato.pdf",
+ *   casoId: "caso-uuid",
+ *   casoTypeId: "tipo-uuid",
+ * };
+ * ```
+ */
+export interface UploadDocumentRequest {
+  /** Archivo a subir (File del browser o Blob) */
+  file: Blob | File;
+  /** UUID del caso al que se asocia el documento */
+  casoId: string;
+  /** UUID del tipo de caso */
+  casoTypeId: string;
+  /** Nombre del archivo. Si no se especifica, usa `file.name` (solo para `File`) */
+  fileName?: string;
+  /** UUID de la categoría del documento. Opcional */
+  categoryId?: string;
+  /** Indica si el documento es válido. Por defecto: `false` */
+  isValid?: boolean;
+  /** Indica si el documento está eliminado lógicamente. Por defecto: `false` */
+  isDeleted?: boolean;
+  /** Indica si el documento está cifrado. Por defecto: `false` */
+  encrypted?: boolean;
+}

package/src/modules/repo/repoDocumentModule.ts

@@ -0,0 +1,94 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import type { UploadDocumentRequest } from "./dto/uploadDocumentRequest.js";
+
+/**
+ * Sub-módulo para gestión de documentos en el repositorio de Shori.
+ *
+ * Proporciona operaciones de escritura: subida y eliminación de documentos.
+ * Se accede a través de `client.repo().document()`.
+ *
+ * @example
+ * ```ts
+ * // Subir un documento
+ * const documentId = await client.repo().document().upload({
+ *   file: fileInput.files[0],
+ *   casoId: "caso-uuid",
+ *   casoTypeId: "tipo-uuid",
+ *   isValid: false,
+ *   isDeleted: false,
+ *   encrypted: false,
+ * });
+ *
+ * // Eliminar un documento
+ * await client.repo().document().delete("doc-uuid");
+ * ```
+ */
+export class RepoDocumentModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.config = config;
+    this.http = http;
+  }
+
+  /**
+   * Sube un documento al repositorio de Shori y lo asocia a un caso.
+   *
+   * Los metadatos del request se envían como query params de la URL.
+   * El archivo se envía como cuerpo binario (`application/octet-stream`).
+   *
+   * @example
+   * ```ts
+   * // Desde un <input type="file">
+   * const docId = await client.repo().document().upload({
+   *   file: event.target.files[0],
+   *   casoId: "caso-uuid",
+   *   casoTypeId: "tipo-uuid",
+   *   categoryId: "category-uuid", // opcional
+   * });
+   *
+   * // Desde un Blob generado
+   * const blob = new Blob([content], { type: "application/pdf" });
+   * const docId = await client.repo().document().upload({
+   *   file: blob,
+   *   casoId: "caso-uuid",
+   *   casoTypeId: "tipo-uuid",
+   * });
+   * ```
+   *
+   * @param request - Archivo y metadatos del documento
+   * @returns UUID del documento creado en el repositorio
+   */
+  async upload(request: UploadDocumentRequest): Promise<string> {
+    const params = new URLSearchParams();
+    params.set("casoId", request.casoId);
+    params.set("casoTypeId", request.casoTypeId);
+    if (request.categoryId) params.set("categoryId", request.categoryId);
+    if (request.isValid !== undefined)
+      params.set("isValid", String(request.isValid));
+    if (request.isDeleted !== undefined)
+      params.set("isDeleted", String(request.isDeleted));
+    if (request.encrypted !== undefined)
+      params.set("encrypted", String(request.encrypted));
+
+    const url = `${this.config.repoUrl}/v3/documents?${params.toString()}`;
+    return this.http.uploadFile<string>(url, request.file);
+  }
+
+  /**
+   * Elimina un documento del repositorio por su UUID.
+   *
+   * @example
+   * ```ts
+   * await client.repo().document().delete("a1b2c3d4-e5f6-7890-abcd-ef1234567890");
+   * ```
+   *
+   * @param uuid - UUID del documento a eliminar
+   */
+  async delete(uuid: string): Promise<void> {
+    const url = `${this.config.repoUrl}/v3/documents/${uuid}`;
+    return this.http.delete(url);
+  }
+}

package/src/modules/repo/repoDownloadModule.ts

@@ -0,0 +1,120 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import type {
+  GetDocumentByIdRequest,
+  DownloadByDocumentAndVersionRequest,
+} from "./dto/downloadRequests.js";
+
+/**
+ * Sub-módulo para descarga de documentos del repositorio de Shori.
+ *
+ * Todas las descargas retornan un `File` — compatible con browser, Node.js 20+,
+ * Next.js y NestJS. El `File` contiene los bytes del documento y el nombre
+ * especificado en el request (o `"document"` por defecto).
+ *
+ * Se accede a través de `client.repo().download()`.
+ *
+ * @example
+ * ```ts
+ * // Descargar y guardar en el navegador
+ * const file = await client.repo().download().byDocument({
+ *   documentId: "uuid",
+ *   fileName: "contrato.pdf",
+ * });
+ * const url = URL.createObjectURL(file);
+ * const a = document.createElement("a");
+ * a.href = url;
+ * a.download = file.name; // "contrato.pdf"
+ * a.click();
+ *
+ * // Descargar y guardar en Node.js
+ * const file = await client.repo().download().byDocument({
+ *   documentId: "uuid",
+ *   fileName: "contrato.pdf",
+ * });
+ * const buffer = Buffer.from(await file.arrayBuffer());
+ * await fs.promises.writeFile(`/descargas/${file.name}`, buffer);
+ * ```
+ */
+export class RepoDownloadModule {
+  private readonly config: ShoriConfig;
+  private readonly http: HttpExecutor;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.config = config;
+    this.http = http;
+  }
+
+  /**
+   * Descarga un documento del repositorio por su UUID.
+   *
+   * @example
+   * ```ts
+   * const file = await client.repo().download().byDocument({
+   *   documentId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+   *   fileName: "contrato-firmado.pdf",
+   * });
+   * console.log(file.name); // "contrato-firmado.pdf"
+   * console.log(file.size); // bytes
+   * ```
+   *
+   * @param request - UUID del documento y nombre del archivo
+   * @returns `File` con el contenido del documento
+   */
+  async byDocument(request: GetDocumentByIdRequest): Promise<File> {
+    const url = `${this.config.repoUrl}/v3/download/${request.documentId}`;
+    const blob = await this.http.downloadBlob(url);
+    return new File([blob], request.fileName ?? "document", {
+      type: blob.type,
+    });
+  }
+
+  /**
+   * Descarga una versión específica de un documento.
+   *
+   * @example
+   * ```ts
+   * const file = await client.repo().download().byDocumentAndVersion({
+   *   documentId: "doc-uuid",
+   *   versionId: "version-uuid",
+   *   fileName: "contrato-v2.pdf",
+   * });
+   * ```
+   *
+   * @param request - UUID del documento, UUID de la versión y nombre del archivo
+   * @returns `File` con el contenido de esa versión
+   */
+  async byDocumentAndVersion(
+    request: DownloadByDocumentAndVersionRequest,
+  ): Promise<File> {
+    const url = `${this.config.repoUrl}/v3/download/${request.documentId}/version/${request.versionId}`;
+    const blob = await this.http.downloadBlob(url);
+    return new File([blob], request.fileName ?? "document", {
+      type: blob.type,
+    });
+  }
+
+  /**
+   * Descarga la versión exportada de un documento (formato generado por Shori, habitualmente PDF).
+   *
+   * @example
+   * ```ts
+   * const file = await client.repo().download().exportDocument({
+   *   documentId: "doc-uuid",
+   *   fileName: "documento-exportado.pdf",
+   * });
+   * // Convertir a ArrayBuffer para procesarlo
+   * const buffer = await file.arrayBuffer();
+   * ```
+   *
+   * @param request - UUID del documento y nombre del archivo
+   * @returns `File` con el documento en formato exportado
+   */
+  async exportDocument(request: GetDocumentByIdRequest): Promise<File> {
+    const url = `${this.config.repoUrl}/v3/download/${request.documentId}/export`;
+    const blob = await this.http.downloadBlob(url);
+    return new File([blob], request.fileName ?? "document", {
+      type: blob.type,
+    });
+  }
+}

package/src/modules/repo/repoModule.ts

@@ -0,0 +1,74 @@
+import type { HttpExecutor } from "../../http/HttpExecutor.js";
+import type { ShoriConfig } from "../../config/ShoriConfig.js";
+import { RepoDocumentModule } from "./repoDocumentModule.js";
+import { RepoDownloadModule } from "./repoDownloadModule.js";
+
+/**
+ * Módulo de Repositorio de Documentos de Shori.
+ *
+ * Façade que agrupa los sub-módulos `document` y `download`.
+ * Se accede a través de `client.repo()`.
+ *
+ * @example
+ * ```ts
+ * // Subir un documento
+ * const docId = await client.repo().document().upload({
+ *   file: fileInput.files[0],
+ *   casoId: "caso-uuid",
+ *   casoTypeId: "tipo-uuid",
+ * });
+ *
+ * // Descargar un documento
+ * const blob = await client.repo().download().byDocument({ documentId: docId });
+ * const url = URL.createObjectURL(blob);
+ *
+ * // Descargar versión específica
+ * const blob2 = await client.repo().download().byDocumentAndVersion({
+ *   documentId: "doc-uuid",
+ *   versionId: "ver-uuid",
+ * });
+ *
+ * // Descargar versión exportada (PDF)
+ * const pdfBlob = await client.repo().download().exportDocument({ documentId: "doc-uuid" });
+ * ```
+ */
+export class RepoModule {
+  private readonly documentModule: RepoDocumentModule;
+  private readonly downloadModule: RepoDownloadModule;
+
+  constructor(config: ShoriConfig, http: HttpExecutor) {
+    this.documentModule = new RepoDocumentModule(config, http);
+    this.downloadModule = new RepoDownloadModule(config, http);
+  }
+
+  /**
+   * Accede al sub-módulo de gestión de documentos.
+   *
+   * Permite subir y eliminar documentos del repositorio.
+   *
+   * @example
+   * ```ts
+   * const docId = await client.repo().document().upload({ file, casoId, casoTypeId });
+   * await client.repo().document().delete("doc-uuid");
+   * ```
+   */
+  document(): RepoDocumentModule {
+    return this.documentModule;
+  }
+
+  /**
+   * Accede al sub-módulo de descarga de documentos.
+   *
+   * Todas las descargas retornan un `Blob`.
+   *
+   * @example
+   * ```ts
+   * const blob = await client.repo().download().byDocument({ documentId: "uuid" });
+   * const blob2 = await client.repo().download().byDocumentAndVersion({ documentId, versionId });
+   * const pdf = await client.repo().download().exportDocument({ documentId: "uuid" });
+   * ```
+   */
+  download(): RepoDownloadModule {
+    return this.downloadModule;
+  }
+}