Client interfaces (DI)

interface IImportClient {
  uploadFile(
    file: File,
    risorsa: string,
    opzioniCsv?: Partial<CsvOpzioni>,
    valoriFissi?: Record<string, unknown>   // dalla 0.2.5
  ): Promise<UploadResult>
  testImport(sessionId: string, mappings: MappingColonna[]): Promise<TestImportResult>
  executeImport(sessionId: string, mappings: MappingColonna[]): Promise<ImportResult>
  getImportStatus(importId: string): Promise<ImportProgresso>
  uploadImages(sessionId: string, files: File[]): Promise<{ caricati: number; errori: string[] }>
  downloadTemplate(risorsa: string, formato: string): Promise<Blob>
  getImportHistory(risorsa?: string): Promise<ImportHistoryItem[]>
  getImportFieldMetadata(risorsa: string): Promise<CampoMetadato[]>
  cancelUpload(): void
}

interface IExportClient {
  executeExport(request: ExportRequest): Promise<ServerAsyncExportPayload | Blob>
  getExportStatus(exportId: string): Promise<ExportProgresso>
  downloadExport(url: string): Promise<Blob>
  getExportFieldMetadata(risorsa: string): Promise<CampoMetadato[]>
  cancelExport(): void
}

interface ITemplateClient {
  getTemplates(risorsa?: string): Promise<ModelloExport[]>
  createTemplate(
    template: Omit<ModelloExport, 'id' | 'dataCreazione' | 'dataModifica' | 'creatoDa'>
  ): Promise<ModelloExport>
  updateTemplate(id: string, template: Partial<ModelloExport>): Promise<ModelloExport>
  deleteTemplate(id: string): Promise<void>
}

type ImportExportClient = IImportClient & IExportClient & ITemplateClient

import { describe, it, expect, vi } from 'vitest'
import { mount } from '@vue/test-utils'
import { ImportWizard, type ImportExportClient } from '@pzeta/vue-importexport'

const mockClient = {
  // Solo i metodi che il test esercita
  uploadFile: vi.fn().mockResolvedValue({
    sessionId: 'sess-1',
    righe: 100,
    colonne: ['nome', 'cognome', 'email'],
  }),
  getImportFieldMetadata: vi.fn().mockResolvedValue([
    { nome: 'nome', etichetta: 'Nome', tipo: 'string', obbligatorio: true },
    { nome: 'cognome', etichetta: 'Cognome', tipo: 'string', obbligatorio: true },
    { nome: 'email', etichetta: 'Email', tipo: 'email', obbligatorio: false },
  ]),
  testImport: vi.fn().mockResolvedValue({ righeValide: 98, righeErrore: 2, errori: [] }),
  executeImport: vi.fn().mockResolvedValue({
    stato: 'completato',
    righeImportate: 98,
    righeScartate: 2,
  }),
  cancelUpload: vi.fn(),
  // I restanti metodi delle 3 interfacce non sono toccati nel test
} as unknown as ImportExportClient

it("esegue l'upload e il test", async () => {
  const wrapper = mount(ImportWizard, {
    props: {
      visible: true,
      baseUrl: 'http://localhost',
      risorsa: 'anagrafica',
      api: mockClient,
    },
  })

  // ... interagisci col wizard
  expect(mockClient.uploadFile).toHaveBeenCalled()
})

import type {
  IImportClient,
  IExportClient,
  ITemplateClient,
  ImportExportClient,
} from '@pzeta/vue-importexport'
import type { GraphQLClient } from 'graphql-request'

class GraphQLImportClient implements IImportClient {
  constructor(private readonly gql: GraphQLClient) {}

  async uploadFile(file, risorsa, opzioniCsv, valoriFissi) {
    // GraphQL multipart upload spec
    const { upload } = await this.gql.request(UPLOAD_MUTATION, { file, risorsa, opzioniCsv, valoriFissi })
    return upload
  }

  async testImport(sessionId, mappings) {
    const { test } = await this.gql.request(TEST_MUTATION, { sessionId, mappings })
    return test
  }

  async executeImport(sessionId, mappings) {
    const { execute } = await this.gql.request(EXECUTE_MUTATION, { sessionId, mappings })
    return execute
  }

  async getImportStatus(importId) {
    const { status } = await this.gql.request(STATUS_QUERY, { importId })
    return status
  }

  async uploadImages(sessionId, files) { /* ... */ }
  async downloadTemplate(risorsa, formato) {
    // GraphQL non gestisce binari: fallback a endpoint REST/CDN dedicato
    const res = await fetch(`/import/template/${risorsa}?formato=${formato}`)
    return res.blob()
  }
  async getImportHistory(risorsa) { /* ... */ }
  async getImportFieldMetadata(risorsa) { /* ... */ }
  cancelUpload() { /* GraphQL request abort */ }
}

class GraphQLExportClient implements IExportClient { /* ... */ }
class GraphQLTemplateClient implements ITemplateClient { /* ... */ }

// Composizione delle 3 implementazioni
function createGraphQLClient(gql: GraphQLClient): ImportExportClient {
  const importer = new GraphQLImportClient(gql)
  const exporter = new GraphQLExportClient(gql)
  const templates = new GraphQLTemplateClient(gql)

  // I metodi di classe stanno sul prototipo: Object.assign / spread non li copierebbero.
  // Si delega esplicitamente, così `this` resta quello di ogni implementazione.
  return {
    uploadFile: (...a) => importer.uploadFile(...a),
    testImport: (...a) => importer.testImport(...a),
    executeImport: (...a) => importer.executeImport(...a),
    getImportStatus: (...a) => importer.getImportStatus(...a),
    uploadImages: (...a) => importer.uploadImages(...a),
    downloadTemplate: (...a) => importer.downloadTemplate(...a),
    getImportHistory: (...a) => importer.getImportHistory(...a),
    getImportFieldMetadata: (...a) => importer.getImportFieldMetadata(...a),
    cancelUpload: () => importer.cancelUpload(),
    executeExport: (...a) => exporter.executeExport(...a),
    getExportStatus: (...a) => exporter.getExportStatus(...a),
    downloadExport: (...a) => exporter.downloadExport(...a),
    getExportFieldMetadata: (...a) => exporter.getExportFieldMetadata(...a),
    cancelExport: () => exporter.cancelExport(),
    getTemplates: (...a) => templates.getTemplates(...a),
    createTemplate: (...a) => templates.createTemplate(...a),
    updateTemplate: (...a) => templates.updateTemplate(...a),
    deleteTemplate: (...a) => templates.deleteTemplate(...a),
  }
}

const myClient = createGraphQLClient(myGraphQLClient)

<ImportWizard :api="myClient" base-url="" risorsa="anagrafica" />

import { ImportExportApi, type ImportExportApiOptions } from '@pzeta/vue-importexport'
import type { CampoMetadato } from '@pzeta/vue-importexport'

class CachedImportExportApi extends ImportExportApi {
  private metadataCache = new Map<string, CampoMetadato[]>()

  constructor(baseUrl: string, options?: ImportExportApiOptions) {
    super(baseUrl, options)
  }

  async getImportFieldMetadata(risorsa: string): Promise<CampoMetadato[]> {
    if (this.metadataCache.has(risorsa)) {
      return this.metadataCache.get(risorsa)!
    }
    const fields = await super.getImportFieldMetadata(risorsa)
    this.metadataCache.set(risorsa, fields)
    return fields
  }
}

const api = new CachedImportExportApi(baseUrl)

<ImportWizard :api="api" :base-url="baseUrl" risorsa="anagrafica" />

<script setup lang="ts">
import { ImportExportApi, useImport, ImportStepUpload } from '@pzeta/vue-importexport'

const api = new ImportExportApi(import.meta.env.VITE_IMPORTEXPORT_API_URL)
// Niente provide: il client arriva come argomento
const { file, formato, risorsa, opzioniCsv, loading, errore, setFile, upload, cancelUpload, downloadTemplate } =
  useImport(api)
risorsa.value = 'anagrafica'

// Come ImportWizard: scelto il file, l'upload parte subito
async function onSelectFile(f: File) {
  setFile(f)
  await upload()
}
</script>

<template>
  <ImportStepUpload
    :file="file"
    :formato="formato"
    :risorsa="risorsa"
    :opzioni-csv="opzioniCsv"
    :loading="loading"
    :errore="errore"
    @select-file="onSelectFile"
    @update:opzioni-csv="opzioniCsv = $event"
    @cancel-upload="cancelUpload"
    @download-template="downloadTemplate"
  />
</template>

import type {
  IImportClient,
  IExportClient,
  ITemplateClient,
  ImportExportClient,
  ImportExportApiOptions,
} from '@pzeta/vue-importexport'

import { ImportExportApi } from '@pzeta/vue-importexport'