@fast-white-cat/integration-ksef-direct 0.1.0

package/src/modules/integration_ksef_direct/api/get/integration-ksef-direct/documents/[id].ts

@@ -0,0 +1,94 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { KsefDirectDocument } from '../../../../data/entities'
+
+export const metadata = {
+  path: '/integration-ksef-direct/documents/[id]',
+  GET: { requireAuth: true, requireFeatures: ['integration_ksef_direct.documents.view'] },
+}
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as any
+
+  const doc = await em.findOne(KsefDirectDocument, {
+    id: params.id,
+    organizationId: auth.orgId,
+    tenantId: auth.tenantId,
+  })
+
+  if (!doc) {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 })
+  }
+
+  return NextResponse.json({
+    id: doc.id,
+    source: doc.source,
+    status: doc.status,
+    invoiceNumber: doc.invoiceNumber,
+    sellerNip: doc.sellerNip,
+    buyerNip: doc.buyerNip,
+    buyerName: doc.buyerName ?? null,
+    issueDate: doc.issueDate.toISOString().split('T')[0],
+    saleDate: doc.saleDate ? doc.saleDate.toISOString().split('T')[0] : null,
+    netAmount: doc.netAmount,
+    vatAmount: doc.vatAmount,
+    grossAmount: doc.grossAmount,
+    currency: doc.currency,
+    lineItems: doc.lineItems,
+    notes: doc.notes ?? null,
+    ksefReferenceNumber: doc.ksefReferenceNumber ?? null,
+    errorMessage: doc.errorMessage ?? null,
+    createdAt: doc.createdAt.toISOString(),
+    updatedAt: doc.updatedAt.toISOString(),
+  })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'KSeF Direct',
+  summary: 'Get KSeF Direct document',
+  methods: {
+    GET: {
+      summary: 'Get a single KSeF Direct document',
+      description: 'Returns the full document record including line items.',
+      responses: [
+        {
+          status: 200,
+          description: 'Document record',
+          schema: z.object({
+            id: z.string().uuid(),
+            source: z.string(),
+            status: z.string(),
+            invoiceNumber: z.string(),
+            sellerNip: z.string(),
+            buyerNip: z.string(),
+            buyerName: z.string().nullable(),
+            issueDate: z.string(),
+            saleDate: z.string().nullable(),
+            netAmount: z.string(),
+            vatAmount: z.string(),
+            grossAmount: z.string(),
+            currency: z.string(),
+            lineItems: z.array(z.record(z.unknown())),
+            notes: z.string().nullable(),
+            ksefReferenceNumber: z.string().nullable(),
+            errorMessage: z.string().nullable(),
+            createdAt: z.string(),
+            updatedAt: z.string(),
+          }),
+        },
+      ],
+      errors: [
+        { status: 404, description: 'Document not found', schema: z.object({ error: z.string() }) },
+      ],
+    },
+  },
+}

package/src/modules/integration_ksef_direct/api/get/integration-ksef-direct/documents.ts

@@ -0,0 +1,111 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { KsefDirectDocument } from '../../../data/entities'
+
+export const metadata = {
+  path: '/integration-ksef-direct/documents',
+  GET: { requireAuth: true, requireFeatures: ['integration_ksef_direct.documents.view'] },
+}
+
+const querySchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  pageSize: z.coerce.number().min(1).max(100).default(50),
+  status: z.string().optional(),
+  source: z.string().optional(),
+  search: z.string().optional(),
+})
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const url = new URL(req.url)
+  const parsed = querySchema.safeParse(Object.fromEntries(url.searchParams.entries()))
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid query' }, { status: 400 })
+  }
+  const query = parsed.data
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as any
+
+  const where: Record<string, unknown> = {
+    organizationId: auth.orgId,
+    tenantId: auth.tenantId,
+  }
+
+  if (query.status) where.status = query.status
+  if (query.source) where.source = query.source
+
+  const [docs, total] = await em.findAndCount(
+    KsefDirectDocument,
+    where,
+    {
+      orderBy: { createdAt: 'DESC' },
+      limit: query.pageSize,
+      offset: (query.page - 1) * query.pageSize,
+    },
+  )
+
+  const items = docs.map((doc: KsefDirectDocument) => ({
+    id: doc.id,
+    source: doc.source,
+    status: doc.status,
+    invoiceNumber: doc.invoiceNumber,
+    buyerNip: doc.buyerNip,
+    buyerName: doc.buyerName ?? null,
+    issueDate: doc.issueDate.toISOString().split('T')[0],
+    sellerNip: doc.sellerNip,
+    netAmount: doc.netAmount,
+    vatAmount: doc.vatAmount,
+    grossAmount: doc.grossAmount,
+    currency: doc.currency,
+    ksefReferenceNumber: doc.ksefReferenceNumber ?? null,
+    createdAt: doc.createdAt.toISOString(),
+  }))
+
+  return NextResponse.json({ items, total, page: query.page, pageSize: query.pageSize })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'KSeF Direct',
+  summary: 'List KSeF Direct documents',
+  methods: {
+    GET: {
+      summary: 'List KSeF Direct documents',
+      description: 'Returns a paginated list of KSeF Direct document records for the current organization.',
+      responses: [
+        {
+          status: 200,
+          description: 'Paginated list',
+          schema: z.object({
+            items: z.array(z.object({
+              id: z.string().uuid(),
+              source: z.string(),
+              status: z.string(),
+              invoiceNumber: z.string(),
+              buyerNip: z.string(),
+              buyerName: z.string().nullable(),
+              issueDate: z.string(),
+              sellerNip: z.string(),
+              netAmount: z.string(),
+              vatAmount: z.string(),
+              grossAmount: z.string(),
+              currency: z.string(),
+              ksefReferenceNumber: z.string().nullable(),
+              createdAt: z.string(),
+            })),
+            total: z.number(),
+            page: z.number(),
+            pageSize: z.number(),
+          }),
+        },
+      ],
+    },
+  },
+}

package/src/modules/integration_ksef_direct/api/get/integration-ksef-direct/health.ts

@@ -0,0 +1,194 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { verifyAccess, KsefAuthError, KsefNetworkError } from '../../../lib/ksefClient'
+import type { KsefCredentials } from '../../../lib/ksefClient'
+import { KsefDirectCredentialsSchema } from '../../../data/validators'
+
+export const metadata = {
+  path: '/integration-ksef-direct/health',
+  GET: { requireAuth: true, requireFeatures: ['integration_ksef_direct.manage'] },
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const credentialsService = container.resolve('integrationCredentialsService') as any
+  const em = container.resolve('em') as any
+
+  const { KsefDirectConnection } = await import('../../../data/entities')
+  const { emitKsefDirectEvent } = await import('../../../events')
+
+  const rawCredentials = credentialsService
+    ? await credentialsService.resolve('integration_ksef_direct', {
+        tenantId: auth.tenantId,
+        organizationId: auth.orgId,
+      })
+    : null
+
+  const credentialsParsed = rawCredentials
+    ? KsefDirectCredentialsSchema.safeParse(rawCredentials)
+    : null
+
+  if (!credentialsParsed?.success) {
+    await upsertConnection(em, KsefDirectConnection, auth.orgId, auth.tenantId, {
+      status: 'unconfigured',
+      lastCheckedAt: null,
+      errorMessage: null,
+      errorCode: null,
+    })
+    return NextResponse.json({ status: 'unconfigured', lastCheckedAt: null })
+  }
+
+  const credentials: KsefCredentials = {
+    ksefToken: credentialsParsed.data.ksef_token,
+    nip: credentialsParsed.data.nip,
+    environment: credentialsParsed.data.environment,
+  }
+
+  await upsertConnection(em, KsefDirectConnection, auth.orgId, auth.tenantId, {
+    status: 'checking',
+    lastCheckedAt: null,
+    errorMessage: null,
+    errorCode: null,
+  })
+
+  try {
+    const rateLimits = await verifyAccess(credentials)
+    const now = new Date()
+
+    await upsertConnection(em, KsefDirectConnection, auth.orgId, auth.tenantId, {
+      status: 'connected',
+      lastCheckedAt: now,
+      errorMessage: null,
+      errorCode: null,
+    })
+
+    await emitKsefDirectEvent('ksef_direct.connection.checked', {
+      organizationId: auth.orgId,
+      tenantId: auth.tenantId,
+    })
+    await emitKsefDirectEvent('ksef_direct.connection.connected', {
+      organizationId: auth.orgId,
+      tenantId: auth.tenantId,
+    })
+
+    return NextResponse.json({
+      status: 'connected',
+      lastCheckedAt: now.toISOString(),
+      environment: credentials.environment,
+      rateLimits,
+    })
+  } catch (err) {
+    const now = new Date()
+    const errorMessage = err instanceof Error ? err.message : 'Unknown error'
+    const errorCode =
+      err instanceof KsefAuthError
+        ? err.errorCode
+        : err instanceof KsefNetworkError
+          ? err.errorCode
+          : 'UNKNOWN_ERROR'
+
+    await upsertConnection(em, KsefDirectConnection, auth.orgId, auth.tenantId, {
+      status: 'error',
+      lastCheckedAt: now,
+      errorMessage,
+      errorCode,
+    })
+
+    await emitKsefDirectEvent('ksef_direct.connection.checked', {
+      organizationId: auth.orgId,
+      tenantId: auth.tenantId,
+    })
+    await emitKsefDirectEvent('ksef_direct.connection.failed', {
+      organizationId: auth.orgId,
+      tenantId: auth.tenantId,
+    })
+
+    return NextResponse.json({
+      status: 'error',
+      lastCheckedAt: now.toISOString(),
+      error: errorMessage,
+      errorCode,
+    })
+  }
+}
+
+interface UpsertPayload {
+  status: 'unconfigured' | 'checking' | 'connected' | 'error'
+  lastCheckedAt: Date | null
+  errorMessage: string | null
+  errorCode: string | null
+}
+
+async function upsertConnection(
+  em: any,
+  KsefDirectConnection: any,
+  organizationId: string,
+  tenantId: string,
+  payload: UpsertPayload,
+): Promise<void> {
+  const existing = await em.findOne(KsefDirectConnection, { organizationId, tenantId })
+  if (existing) {
+    existing.status = payload.status
+    existing.lastCheckedAt = payload.lastCheckedAt
+    existing.errorMessage = payload.errorMessage
+    existing.errorCode = payload.errorCode
+    existing.updatedAt = new Date()
+    await em.flush()
+  } else {
+    const connection = em.create(KsefDirectConnection, {
+      organizationId,
+      tenantId,
+      status: payload.status,
+      lastCheckedAt: payload.lastCheckedAt,
+      errorMessage: payload.errorMessage,
+      errorCode: payload.errorCode,
+    })
+    await em.persist(connection).flush()
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'KSeF Direct',
+  summary: 'KSeF Direct health check',
+  methods: {
+    GET: {
+      summary: 'Check KSeF Direct connection health',
+      description: 'Performs a full authentication flow against the KSeF MF API v2 and returns connection status.',
+      responses: [
+        {
+          status: 200,
+          description: 'Health check result',
+          schema: z.union([
+            z.object({
+              status: z.literal('connected'),
+              lastCheckedAt: z.string(),
+              environment: z.enum(['test', 'production']),
+              rateLimits: z.object({
+                otherPerSecond: z.number().optional(),
+                otherPerMinute: z.number().optional(),
+              }).optional(),
+            }),
+            z.object({
+              status: z.literal('error'),
+              lastCheckedAt: z.string(),
+              error: z.string(),
+              errorCode: z.string(),
+            }),
+            z.object({
+              status: z.literal('unconfigured'),
+              lastCheckedAt: z.null(),
+            }),
+          ]),
+        },
+      ],
+    },
+  },
+}

package/src/modules/integration_ksef_direct/api/get/integration-ksef-direct/received-documents/[id].ts

@@ -0,0 +1,88 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { KsefDirectReceivedDocument } from '../../../../data/entities'
+
+export const metadata = {
+  path: '/integration-ksef-direct/received-documents/[id]',
+  GET: { requireAuth: true, requireFeatures: ['integration_ksef_direct.received_documents.view'] },
+}
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as any
+
+  const doc = await em.findOne(KsefDirectReceivedDocument, {
+    id: params.id,
+    organizationId: auth.orgId,
+    tenantId: auth.tenantId,
+  })
+
+  if (!doc) {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 })
+  }
+
+  return NextResponse.json({
+    id: doc.id,
+    ksefReferenceNumber: doc.ksefReferenceNumber,
+    invoiceNumber: doc.invoiceNumber ?? null,
+    sellerNip: doc.sellerNip ?? null,
+    sellerName: doc.sellerName ?? null,
+    issueDate: doc.issueDate ?? null,
+    currency: doc.currency ?? null,
+    netAmount: doc.netAmount ?? null,
+    vatAmount: doc.vatAmount ?? null,
+    grossAmount: doc.grossAmount ?? null,
+    rawXml: doc.rawXml ?? null,
+    status: doc.status,
+    errorMessage: doc.errorMessage ?? null,
+    syncedAt: doc.syncedAt?.toISOString() ?? null,
+    createdAt: doc.createdAt.toISOString(),
+    updatedAt: doc.updatedAt.toISOString(),
+  })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'KSeF Direct',
+  summary: 'Get received KSeF document',
+  methods: {
+    GET: {
+      summary: 'Get a single received KSeF document',
+      description: 'Returns the full received document record including raw FA(2) XML.',
+      responses: [
+        {
+          status: 200,
+          description: 'Document record',
+          schema: z.object({
+            id: z.string().uuid(),
+            ksefReferenceNumber: z.string(),
+            invoiceNumber: z.string().nullable(),
+            sellerNip: z.string().nullable(),
+            sellerName: z.string().nullable(),
+            issueDate: z.string().nullable(),
+            currency: z.string().nullable(),
+            netAmount: z.string().nullable(),
+            vatAmount: z.string().nullable(),
+            grossAmount: z.string().nullable(),
+            rawXml: z.string().nullable(),
+            status: z.string(),
+            errorMessage: z.string().nullable(),
+            syncedAt: z.string().nullable(),
+            createdAt: z.string(),
+            updatedAt: z.string(),
+          }),
+        },
+      ],
+      errors: [
+        { status: 404, description: 'Not found', schema: z.object({ error: z.string() }) },
+      ],
+    },
+  },
+}

package/src/modules/integration_ksef_direct/api/get/integration-ksef-direct/received-documents.ts

@@ -0,0 +1,119 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { KsefDirectReceivedDocument } from '../../../data/entities'
+
+export const metadata = {
+  path: '/integration-ksef-direct/received-documents',
+  GET: { requireAuth: true, requireFeatures: ['integration_ksef_direct.received_documents.view'] },
+}
+
+const querySchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  pageSize: z.coerce.number().min(1).max(100).default(50),
+  status: z.string().optional(),
+  search: z.string().optional(),
+})
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const url = new URL(req.url)
+  const parsed = querySchema.safeParse(Object.fromEntries(url.searchParams.entries()))
+  if (!parsed.success) {
+    return NextResponse.json({ error: 'Invalid query' }, { status: 400 })
+  }
+  const query = parsed.data
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as any
+
+  const where: Record<string, unknown> = {
+    organizationId: auth.orgId,
+    tenantId: auth.tenantId,
+  }
+
+  if (query.status) where.status = query.status
+
+  if (query.search) {
+    const pattern = `%${query.search}%`
+    where.$or = [
+      { ksefReferenceNumber: { $ilike: pattern } },
+      { invoiceNumber: { $ilike: pattern } },
+      { sellerNip: { $ilike: pattern } },
+      { sellerName: { $ilike: pattern } },
+    ]
+  }
+
+  const [docs, total] = await em.findAndCount(
+    KsefDirectReceivedDocument,
+    where,
+    {
+      orderBy: { createdAt: 'DESC' },
+      limit: query.pageSize,
+      offset: (query.page - 1) * query.pageSize,
+    },
+  )
+
+  const items = docs.map((doc: KsefDirectReceivedDocument) => ({
+    id: doc.id,
+    ksefReferenceNumber: doc.ksefReferenceNumber,
+    invoiceNumber: doc.invoiceNumber ?? null,
+    sellerNip: doc.sellerNip ?? null,
+    sellerName: doc.sellerName ?? null,
+    issueDate: doc.issueDate ?? null,
+    currency: doc.currency ?? null,
+    netAmount: doc.netAmount ?? null,
+    vatAmount: doc.vatAmount ?? null,
+    grossAmount: doc.grossAmount ?? null,
+    status: doc.status,
+    errorMessage: doc.errorMessage ?? null,
+    syncedAt: doc.syncedAt?.toISOString() ?? null,
+    createdAt: doc.createdAt.toISOString(),
+  }))
+
+  return NextResponse.json({ items, total, page: query.page, pageSize: query.pageSize })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'KSeF Direct',
+  summary: 'List received KSeF documents',
+  methods: {
+    GET: {
+      summary: 'List received KSeF documents',
+      description: 'Returns a paginated list of received KSeF document records for the current organization.',
+      responses: [
+        {
+          status: 200,
+          description: 'Paginated list',
+          schema: z.object({
+            items: z.array(z.object({
+              id: z.string().uuid(),
+              ksefReferenceNumber: z.string(),
+              invoiceNumber: z.string().nullable(),
+              sellerNip: z.string().nullable(),
+              sellerName: z.string().nullable(),
+              issueDate: z.string().nullable(),
+              currency: z.string().nullable(),
+              netAmount: z.string().nullable(),
+              vatAmount: z.string().nullable(),
+              grossAmount: z.string().nullable(),
+              status: z.string(),
+              errorMessage: z.string().nullable(),
+              syncedAt: z.string().nullable(),
+              createdAt: z.string(),
+            })),
+            total: z.number(),
+            page: z.number(),
+            pageSize: z.number(),
+          }),
+        },
+      ],
+    },
+  },
+}

package/src/modules/integration_ksef_direct/api/get/integration-ksef-direct/seller-info.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { KsefDirectCredentialsSchema } from '../../../data/validators'
+
+export const metadata = {
+  path: '/integration-ksef-direct/seller-info',
+  GET: { requireAuth: true, requireFeatures: ['integration_ksef_direct.documents.create'] },
+}
+
+export async function GET(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.tenantId || !auth.orgId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const credentialsService = container.resolve('integrationCredentialsService') as any
+  const em = container.resolve('em') as any
+
+  const rawCredentials = credentialsService
+    ? await credentialsService.resolve('integration_ksef_direct', {
+        tenantId: auth.tenantId,
+        organizationId: auth.orgId,
+      })
+    : null
+
+  const credentialsParsed = rawCredentials
+    ? KsefDirectCredentialsSchema.safeParse(rawCredentials)
+    : null
+
+  const sellerNip = credentialsParsed?.success ? credentialsParsed.data.nip : null
+
+  const { Organization } = await import('@open-mercato/core/modules/directory/data/entities')
+  const org = await em.findOne(Organization, { id: auth.orgId })
+  const sellerName = org?.name ?? null
+
+  return NextResponse.json({ sellerNip, sellerName })
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'KSeF Direct',
+  summary: 'Get KSeF Direct seller info',
+  methods: {
+    GET: {
+      summary: 'Get seller NIP and name for the current tenant',
+      description: 'Returns seller NIP from KSeF credentials and seller name from the current Organization.',
+      responses: [
+        {
+          status: 200,
+          description: 'Seller info',
+          schema: z.object({
+            sellerNip: z.string().nullable(),
+            sellerName: z.string().nullable(),
+          }),
+        },
+      ],
+    },
+  },
+}