@open-mercato/core 0.4.9-develop-e55592929f → 0.4.9-develop-ce96cffe00

package/src/helpers/integration/currenciesFixtures.ts

@@ -0,0 +1,49 @@
+import { expect, type APIRequestContext } from '@playwright/test';
+import { apiRequest } from './api';
+import { getTokenContext } from './generalFixtures';
+
+export async function createCurrencyFixture(
+  request: APIRequestContext,
+  token: string,
+  input: { code: string; name: string; symbol?: string },
+): Promise<string> {
+  const { organizationId, tenantId } = getTokenContext(token);
+  const response = await apiRequest(request, 'POST', '/api/currencies/currencies', {
+    token,
+    data: { organizationId, tenantId, code: input.code, name: input.name, symbol: input.symbol ?? null },
+  });
+  expect(response.ok(), `Failed to create currency fixture: ${response.status()}`).toBeTruthy();
+  const body = (await response.json()) as { id?: string };
+  expect(typeof body.id === 'string' && body.id.length > 0).toBeTruthy();
+  return body.id as string;
+}
+
+export async function createFetchConfigFixture(
+  request: APIRequestContext,
+  token: string,
+  input: { provider: string; isEnabled: boolean },
+): Promise<string> {
+  const response = await apiRequest(request, 'POST', '/api/currencies/fetch-configs', {
+    token,
+    data: input,
+  });
+  expect(response.ok(), `Failed to create fetch config fixture: ${response.status()}`).toBeTruthy();
+  const body = (await response.json()) as { config?: { id?: string } };
+  const id = body.config?.id;
+  expect(typeof id === 'string' && id.length > 0).toBeTruthy();
+  return id as string;
+}
+
+export async function deleteCurrenciesEntityIfExists(
+  request: APIRequestContext,
+  token: string | null,
+  path: string,
+  id: string | null,
+): Promise<void> {
+  if (!token || !id) return;
+  try {
+    await apiRequest(request, 'DELETE', `${path}?id=${encodeURIComponent(id)}`, { token });
+  } catch {
+    return;
+  }
+}

package/src/helpers/integration/dictionariesFixtures.ts

@@ -0,0 +1,17 @@
+import { expect, type APIRequestContext } from '@playwright/test';
+import { apiRequest } from './api';
+
+export async function createDictionaryFixture(
+  request: APIRequestContext,
+  token: string,
+  input: { key: string; name: string },
+): Promise<string> {
+  const response = await apiRequest(request, 'POST', '/api/dictionaries', {
+    token,
+    data: { key: input.key, name: input.name },
+  });
+  expect(response.ok(), `Failed to create dictionary fixture: ${response.status()}`).toBeTruthy();
+  const body = (await response.json()) as { id?: string };
+  expect(typeof body.id === 'string' && body.id.length > 0).toBeTruthy();
+  return body.id as string;
+}

package/src/helpers/integration/featureTogglesFixtures.ts

@@ -0,0 +1,28 @@
+import { expect, type APIRequestContext } from '@playwright/test';
+import { apiRequest } from './api';
+import { expectId, readJsonSafe } from './generalFixtures';
+
+export async function createFeatureToggleFixture(
+  request: APIRequestContext,
+  token: string,
+  data: Record<string, unknown>,
+): Promise<string> {
+  const response = await apiRequest(request, 'POST', '/api/feature_toggles/global', { token, data });
+  const body = await readJsonSafe<{ id?: string }>(response);
+  expect(response.status(), 'POST /api/feature_toggles/global should return 201').toBe(201);
+  return expectId(body?.id, 'Feature toggle creation response should include id');
+}
+
+export async function deleteFeatureToggleIfExists(
+  request: APIRequestContext,
+  token: string | null,
+  toggleId: string | null,
+): Promise<void> {
+  if (!token || !toggleId) return;
+  await apiRequest(
+    request,
+    'DELETE',
+    `/api/feature_toggles/global?id=${encodeURIComponent(toggleId)}`,
+    { token },
+  ).catch(() => undefined);
+}

package/src/helpers/integration/generalFixtures.ts

@@ -0,0 +1,71 @@
+import { expect, type APIRequestContext, type APIResponse } from '@playwright/test';
+import { apiRequest } from './api';
+
+function readTokenPayload(token: string): { orgId?: string; tenantId?: string; sub?: string } {
+  const parts = token.split('.');
+  return JSON.parse(Buffer.from(parts[1], 'base64url').toString()) as {
+    orgId?: string;
+    tenantId?: string;
+    sub?: string;
+  };
+}
+
+export function getTokenContext(token: string): { organizationId: string; tenantId: string } {
+  const payload = readTokenPayload(token);
+  return { organizationId: payload.orgId ?? '', tenantId: payload.tenantId ?? '' };
+}
+
+export function getTokenScope(token: string): {
+  organizationId: string;
+  tenantId: string;
+  userId: string;
+} {
+  const payload = readTokenPayload(token);
+  return {
+    organizationId: payload.orgId ?? '',
+    tenantId: payload.tenantId ?? '',
+    userId: payload.sub ?? '',
+  };
+}
+
+export async function readJsonSafe<T = unknown>(response: APIResponse): Promise<T | null> {
+  const raw = await response.text();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return null;
+  }
+}
+
+export function expectId(value: unknown, message: string): string {
+  expect(typeof value === 'string' && value.length > 0, message).toBe(true);
+  return value as string;
+}
+
+export async function deleteEntityByPathIfExists(
+  request: APIRequestContext,
+  token: string | null,
+  fullPath: string | null,
+): Promise<void> {
+  if (!token || !fullPath) return;
+  try {
+    await apiRequest(request, 'DELETE', fullPath, { token });
+  } catch {
+    return;
+  }
+}
+
+export async function deleteGeneralEntityIfExists(
+  request: APIRequestContext,
+  token: string | null,
+  path: string,
+  id: string | null,
+): Promise<void> {
+  if (!token || !id) return;
+  try {
+    await apiRequest(request, 'DELETE', `${path}?id=${encodeURIComponent(id)}`, { token });
+  } catch {
+    return;
+  }
+}

package/src/helpers/integration/inboxFixtures.ts

@@ -0,0 +1,94 @@
+import type { APIRequestContext } from '@playwright/test';
+import { apiRequest } from './api';
+import { readJsonSafe } from './crmFixtures';
+
+export async function submitTextExtraction(
+  request: APIRequestContext,
+  token: string,
+  input?: { text?: string; title?: string; metadata?: Record<string, unknown> },
+): Promise<{ ok: boolean; emailId?: string; error?: string; status: number }> {
+  const text = input?.text ?? 'Test email from John Doe <john@example.com> requesting 10 widgets at $5 each.'
+  const title = input?.title ?? `QA Fixture ${Date.now()}`
+
+  const response = await apiRequest(request, 'POST', '/api/inbox_ops/extract', {
+    token,
+    data: { text, title, metadata: input?.metadata },
+  });
+
+  const body = await readJsonSafe<{ ok?: boolean; emailId?: string; error?: string }>(response);
+  return {
+    ok: response.ok(),
+    emailId: body?.emailId ?? undefined,
+    error: body?.error ?? undefined,
+    status: response.status(),
+  };
+}
+
+export async function waitForEmailProcessed(
+  request: APIRequestContext,
+  token: string,
+  emailId: string,
+  timeoutMs = 30000,
+): Promise<{ status: string; proposalId?: string } | null> {
+  const pollInterval = 1000
+  const deadline = Date.now() + timeoutMs
+
+  while (Date.now() < deadline) {
+    const response = await apiRequest(request, 'GET', `/api/inbox_ops/emails/${emailId}`, { token });
+    if (!response.ok()) return null
+
+    const body = await readJsonSafe<{ email?: { status?: string; id?: string } }>(response);
+    const status = body?.email?.status
+
+    if (status === 'processed' || status === 'needs_review' || status === 'failed') {
+      const proposalsResponse = await apiRequest(request, 'GET', '/api/inbox_ops/proposals?pageSize=5', { token });
+      const proposalsBody = await readJsonSafe<{ items?: Array<{ id: string; inboxEmailId?: string }> }>(proposalsResponse);
+      const proposal = proposalsBody?.items?.find((p) => p.inboxEmailId === emailId);
+      return { status, proposalId: proposal?.id };
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollInterval))
+  }
+
+  return null
+}
+
+export async function deleteInboxEmail(
+  request: APIRequestContext,
+  token: string,
+  emailId: string,
+): Promise<void> {
+  await apiRequest(request, 'DELETE', `/api/inbox_ops/emails/${emailId}`, { token }).catch(() => {})
+}
+
+export async function listInboxEmails(
+  request: APIRequestContext,
+  token: string,
+  params?: { status?: string; page?: number; pageSize?: number },
+): Promise<{ items: Array<Record<string, unknown>>; total: number }> {
+  const searchParams = new URLSearchParams();
+  if (params?.status) searchParams.set('status', params.status);
+  if (params?.page) searchParams.set('page', String(params.page));
+  if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
+
+  const path = `/api/inbox_ops/emails${searchParams.toString() ? `?${searchParams}` : ''}`;
+  const response = await apiRequest(request, 'GET', path, { token });
+  const body = await readJsonSafe<{ items?: Array<Record<string, unknown>>; total?: number }>(response);
+  return { items: body?.items ?? [], total: body?.total ?? 0 };
+}
+
+export async function listInboxProposals(
+  request: APIRequestContext,
+  token: string,
+  params?: { status?: string; page?: number; pageSize?: number },
+): Promise<{ items: Array<Record<string, unknown>>; total: number }> {
+  const searchParams = new URLSearchParams();
+  if (params?.status) searchParams.set('status', params.status);
+  if (params?.page) searchParams.set('page', String(params.page));
+  if (params?.pageSize) searchParams.set('pageSize', String(params.pageSize));
+
+  const path = `/api/inbox_ops/proposals${searchParams.toString() ? `?${searchParams}` : ''}`;
+  const response = await apiRequest(request, 'GET', path, { token });
+  const body = await readJsonSafe<{ items?: Array<Record<string, unknown>>; total?: number }>(response);
+  return { items: body?.items ?? [], total: body?.total ?? 0 };
+}

package/src/helpers/integration/notificationsFixtures.ts

@@ -0,0 +1,67 @@
+import { expect, type APIRequestContext } from '@playwright/test';
+import { apiRequest } from './api';
+import { expectId, readJsonSafe } from './generalFixtures';
+
+export async function createNotificationFixture(
+  request: APIRequestContext,
+  token: string,
+  data: Record<string, unknown>,
+): Promise<string> {
+  const response = await apiRequest(request, 'POST', '/api/notifications', { token, data });
+  const body = await readJsonSafe<{ id?: string }>(response);
+  expect(response.status(), 'POST /api/notifications should return 201').toBe(201);
+  return expectId(body?.id, 'Notification creation response should include id');
+}
+
+export async function listNotifications(
+  request: APIRequestContext,
+  token: string,
+  query?: Record<string, string | number | undefined>,
+): Promise<{
+  items: Array<Record<string, unknown>>;
+  total: number;
+}> {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value === undefined) continue;
+    params.set(key, String(value));
+  }
+  const path = `/api/notifications${params.toString() ? `?${params.toString()}` : ''}`;
+  const response = await apiRequest(request, 'GET', path, { token });
+  const body = await readJsonSafe<{ items?: Array<Record<string, unknown>>; total?: number }>(response);
+  expect(response.ok(), `GET ${path} should succeed`).toBeTruthy();
+  return {
+    items: body?.items ?? [],
+    total: body?.total ?? 0,
+  };
+}
+
+export async function dismissNotificationIfExists(
+  request: APIRequestContext,
+  token: string | null,
+  notificationId: string | null,
+): Promise<void> {
+  if (!token || !notificationId) return;
+  await apiRequest(
+    request,
+    'PUT',
+    `/api/notifications/${encodeURIComponent(notificationId)}/dismiss`,
+    { token },
+  ).catch(() => undefined);
+}
+
+export async function dismissNotificationsByType(
+  request: APIRequestContext,
+  token: string | null,
+  type: string | null,
+): Promise<void> {
+  if (!token || !type) return;
+  const notifications = await listNotifications(request, token, { type, pageSize: 100 }).catch(() => null);
+  if (!notifications) return;
+  await Promise.all(
+    notifications.items
+      .map((item) => (typeof item.id === 'string' ? item.id : null))
+      .filter((id): id is string => Boolean(id))
+      .map((id) => dismissNotificationIfExists(request, token, id)),
+  );
+}

package/src/helpers/integration/salesFixtures.ts

@@ -0,0 +1,89 @@
+import { expect, type APIRequestContext } from '@playwright/test';
+import { apiRequest } from './api';
+
+type JsonMap = Record<string, unknown>;
+
+function readId(payload: unknown, keys: string[]): string | null {
+  if (!payload || typeof payload !== 'object') return null;
+  const map = payload as JsonMap;
+  for (const key of keys) {
+    const value = map[key];
+    if (typeof value === 'string' && value.length > 0) return value;
+  }
+  for (const value of Object.values(map)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const nested = readId(value, keys);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+async function createEntity(
+  request: APIRequestContext,
+  token: string,
+  path: string,
+  data: Record<string, unknown>,
+  idKeys: string[],
+): Promise<string> {
+  const response = await apiRequest(request, 'POST', path, { token, data });
+  const body = (await response.json()) as unknown;
+  expect(response.ok(), `Failed POST ${path}: ${response.status()}`).toBeTruthy();
+  const id = readId(body, idKeys);
+  expect(id, `No id in POST ${path} response`).toBeTruthy();
+  return id as string;
+}
+
+export async function createSalesQuoteFixture(
+  request: APIRequestContext,
+  token: string,
+  currencyCode = 'USD',
+): Promise<string> {
+  return createEntity(request, token, '/api/sales/quotes', { currencyCode }, ['id', 'quoteId']);
+}
+
+export async function createSalesOrderFixture(
+  request: APIRequestContext,
+  token: string,
+  currencyCode = 'USD',
+): Promise<string> {
+  return createEntity(request, token, '/api/sales/orders', { currencyCode }, ['id', 'orderId']);
+}
+
+export async function createOrderLineFixture(
+  request: APIRequestContext,
+  token: string,
+  orderId: string,
+  data?: Record<string, unknown>,
+): Promise<string> {
+  return createEntity(
+    request,
+    token,
+    '/api/sales/order-lines',
+    {
+      orderId,
+      currencyCode: 'USD',
+      quantity: 1,
+      name: `QA line ${Date.now()}`,
+      unitPriceNet: 10,
+      unitPriceGross: 12,
+      ...(data ?? {}),
+    },
+    ['id', 'lineId'],
+  );
+}
+
+export async function deleteSalesEntityIfExists(
+  request: APIRequestContext,
+  token: string | null,
+  path: string,
+  id: string | null,
+): Promise<void> {
+  if (!token || !id) return;
+  try {
+    await apiRequest(request, 'DELETE', `${path}?id=${encodeURIComponent(id)}`, { token });
+  } catch {
+    return;
+  }
+}
+