@open-mercato/core 0.8.1-develop.7266.1.8e520bbe03 → 0.8.1-develop.7267.1.2e95af80a6

package/src/modules/availability/api/policies/route.ts

@@ -1,224 +0,0 @@
-import { NextResponse } from 'next/server'
-import { z } from 'zod'
-import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
-import { AvailabilityPolicy } from '../../data/entities'
-import type { EntityManager } from '@mikro-orm/postgresql'
-import type { FilterQuery } from '@mikro-orm/core'
-import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
-import { resolveActiveOrganizationId, organizationScopeRequiredResponse } from '@open-mercato/shared/lib/auth/organizationScope'
-import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
-import { availabilityPolicyCreateSchema, availabilityPolicyUpdateSchema } from '../../data/validators'
-import {
-  createAvailabilityCrudOpenApi,
-  createPagedListResponseSchema,
-  defaultOkResponseSchema,
-} from '../openapi'
-
-const routeMetadata = {
-  GET: { requireAuth: true, requireFeatures: ['availability.policies.view'] },
-  POST: { requireAuth: true, requireFeatures: ['availability.policies.manage'] },
-  PUT: { requireAuth: true, requireFeatures: ['availability.policies.manage'] },
-  DELETE: { requireAuth: true, requireFeatures: ['availability.policies.manage'] },
-}
-
-export const metadata = routeMetadata
-
-const rawBodySchema = z.object({}).loose()
-type CrudInput = Record<string, unknown>
-
-const crud = makeCrudRoute<CrudInput, CrudInput, Record<string, unknown>>({
-  metadata: routeMetadata,
-  orm: {
-    entity: AvailabilityPolicy,
-    idField: 'id',
-    orgField: 'organizationId',
-    tenantField: 'tenantId',
-    softDeleteField: 'deletedAt',
-  },
-  events: {
-    module: 'availability',
-    entity: 'policy',
-    persistent: true,
-  },
-  actions: {
-    create: {
-      commandId: 'availability.policies.create',
-      schema: rawBodySchema,
-      mapInput: ({ parsed }) => parsed,
-      response: ({ result }) => ({ id: String(result.policyId) }),
-      status: 201,
-    },
-    update: {
-      commandId: 'availability.policies.update',
-      schema: rawBodySchema,
-      mapInput: ({ parsed }) => parsed,
-      response: () => ({ ok: true }),
-    },
-    delete: {
-      commandId: 'availability.policies.delete',
-      schema: rawBodySchema,
-      mapInput: ({ raw, ctx }) => ({
-        id: ((raw as Record<string, unknown>).query as Record<string, unknown> | undefined)?.id as string | undefined,
-        organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? undefined,
-        tenantId: ctx.auth?.tenantId ?? undefined,
-      }),
-      response: () => ({ ok: true }),
-    },
-  },
-})
-
-const listQuerySchema = z.object({
-  id: z.uuid().optional(),
-  page: z.coerce.number().min(1).default(1),
-  pageSize: z.coerce.number().min(1).max(100).default(50),
-  storeId: z.uuid().optional(),
-  productId: z.uuid().optional(),
-  variantId: z.uuid().optional(),
-  isActive: z.enum(['true', 'false']).optional(),
-  sortField: z.enum(['createdAt', 'updatedAt']).optional(),
-  sortDir: z.enum(['asc', 'desc']).optional(),
-}).loose()
-
-type AvailabilityPolicyRow = {
-  id: string
-  organizationId: string
-  tenantId: string
-  storeId: string | null
-  productId: string | null
-  variantId: string | null
-  isStockManaged: boolean
-  allowBackorder: boolean
-  backorderLeadTimeDays: number | null
-  preorderReleaseAt: string | null
-  lowStockThreshold: number | null
-  minOrderQuantity: number | null
-  maxOrderQuantity: number | null
-  quantityIncrement: number | null
-  hideWhenOutOfStock: boolean
-  isActive: boolean
-  createdAt: string | null
-  updatedAt: string | null
-}
-
-const toRow = (policy: AvailabilityPolicy): AvailabilityPolicyRow => ({
-  id: String(policy.id),
-  organizationId: String(policy.organizationId),
-  tenantId: String(policy.tenantId),
-  storeId: policy.storeId ?? null,
-  productId: policy.productId ?? null,
-  variantId: policy.variantId ?? null,
-  isStockManaged: !!policy.isStockManaged,
-  allowBackorder: !!policy.allowBackorder,
-  backorderLeadTimeDays: policy.backorderLeadTimeDays ?? null,
-  preorderReleaseAt: policy.preorderReleaseAt ? policy.preorderReleaseAt.toISOString() : null,
-  lowStockThreshold: policy.lowStockThreshold ?? null,
-  minOrderQuantity: policy.minOrderQuantity ?? null,
-  maxOrderQuantity: policy.maxOrderQuantity ?? null,
-  quantityIncrement: policy.quantityIncrement ?? null,
-  hideWhenOutOfStock: !!policy.hideWhenOutOfStock,
-  isActive: !!policy.isActive,
-  createdAt: policy.createdAt ? policy.createdAt.toISOString() : null,
-  updatedAt: policy.updatedAt ? policy.updatedAt.toISOString() : null,
-})
-
-export async function GET(req: Request) {
-  const auth = await getAuthFromRequest(req)
-  if (!auth || !auth.tenantId) {
-    return NextResponse.json({ items: [], total: 0, page: 1, pageSize: 50, totalPages: 1 }, { status: 401 })
-  }
-  const organizationId = resolveActiveOrganizationId(auth)
-  // A superadmin with no organization selected legitimately sees every
-  // organization in the tenant (om_selected_org=__all__); anyone else with
-  // an unresolved scope gets the standard 400, never a 401 (that reads as an
-  // expired session to the client and redirect-loops through session
-  // refresh — see organizationScope.ts).
-  if (!organizationId && !auth.isSuperAdmin) return organizationScopeRequiredResponse()
-
-  const url = new URL(req.url)
-  const parsed = listQuerySchema.safeParse({
-    id: url.searchParams.get('id') ?? undefined,
-    page: url.searchParams.get('page') ?? undefined,
-    pageSize: url.searchParams.get('pageSize') ?? undefined,
-    storeId: url.searchParams.get('storeId') ?? undefined,
-    productId: url.searchParams.get('productId') ?? undefined,
-    variantId: url.searchParams.get('variantId') ?? undefined,
-    isActive: url.searchParams.get('isActive') ?? undefined,
-    sortField: url.searchParams.get('sortField') ?? undefined,
-    sortDir: url.searchParams.get('sortDir') ?? undefined,
-  })
-  if (!parsed.success) {
-    return NextResponse.json({ items: [], total: 0, page: 1, pageSize: 50, totalPages: 1 }, { status: 400 })
-  }
-
-  const container = await createRequestContainer()
-  const em = container.resolve('em') as EntityManager
-
-  const { id, page, pageSize, storeId, productId, variantId, isActive, sortField, sortDir } = parsed.data
-  const filter: FilterQuery<AvailabilityPolicy> = {
-    tenantId: auth.tenantId,
-    deletedAt: null,
-  }
-  if (organizationId) filter.organizationId = organizationId
-  if (id) filter.id = id
-  if (storeId) filter.storeId = storeId
-  if (productId) filter.productId = productId
-  if (variantId) filter.variantId = variantId
-  if (isActive === 'true') filter.isActive = true
-  if (isActive === 'false') filter.isActive = false
-
-  const orderBy: Record<string, 'ASC' | 'DESC'> = {}
-  orderBy[sortField ?? 'createdAt'] = sortDir === 'asc' ? 'ASC' : 'DESC'
-
-  const offset = (page - 1) * pageSize
-  const [rows, total] = await em.findAndCount(AvailabilityPolicy, filter, { orderBy, limit: pageSize, offset })
-  const items = rows.map(toRow)
-  const totalPages = Math.max(1, Math.ceil(total / pageSize))
-
-  return NextResponse.json({ items, total, page, pageSize, totalPages })
-}
-
-export const POST = crud.POST
-export const PUT = crud.PUT
-export const DELETE = crud.DELETE
-
-const availabilityPolicyListItemSchema = z.object({
-  id: z.uuid(),
-  organizationId: z.uuid(),
-  tenantId: z.uuid(),
-  storeId: z.uuid().nullable(),
-  productId: z.uuid().nullable(),
-  variantId: z.uuid().nullable(),
-  isStockManaged: z.boolean(),
-  allowBackorder: z.boolean(),
-  backorderLeadTimeDays: z.number().nullable(),
-  preorderReleaseAt: z.string().nullable(),
-  lowStockThreshold: z.number().nullable(),
-  minOrderQuantity: z.number().nullable(),
-  maxOrderQuantity: z.number().nullable(),
-  quantityIncrement: z.number().nullable(),
-  hideWhenOutOfStock: z.boolean(),
-  isActive: z.boolean(),
-  createdAt: z.string().nullable(),
-  updatedAt: z.string().nullable(),
-})
-
-export const openApi = createAvailabilityCrudOpenApi({
-  resourceName: 'AvailabilityPolicy',
-  pluralName: 'AvailabilityPolicies',
-  querySchema: listQuerySchema,
-  listResponseSchema: createPagedListResponseSchema(availabilityPolicyListItemSchema),
-  create: {
-    schema: availabilityPolicyCreateSchema,
-    description: 'Creates a new availability policy.',
-  },
-  update: {
-    schema: availabilityPolicyUpdateSchema,
-    responseSchema: defaultOkResponseSchema,
-    description: 'Updates an existing availability policy by id.',
-  },
-  del: {
-    schema: z.object({ id: z.string().uuid() }),
-    responseSchema: defaultOkResponseSchema,
-    description: 'Deletes an availability policy by id.',
-  },
-})

package/src/modules/availability/backend/availability/check/page.meta.ts

@@ -1,12 +0,0 @@
-export const metadata = {
-  requireAuth: true,
-  requireFeatures: ['availability.check'],
-  pageTitle: 'Availability Check',
-  pageTitleKey: 'availability.check.nav.title',
-  pageGroup: 'Availability',
-  pageGroupKey: 'availability.nav.group',
-  pageOrder: 20,
-  pageContext: 'settings' as const,
-  icon: 'search',
-  breadcrumb: [{ label: 'Availability Check', labelKey: 'availability.check.nav.title' }],
-}

package/src/modules/availability/backend/availability/check/page.tsx

@@ -1,223 +0,0 @@
-"use client"
-import * as React from 'react'
-import { Page, PageBody } from '@open-mercato/ui/backend/Page'
-import { Input } from '@open-mercato/ui/primitives/input'
-import { Label } from '@open-mercato/ui/primitives/label'
-import { Button } from '@open-mercato/ui/primitives/button'
-import { StatusBadge, type StatusBadgeVariant } from '@open-mercato/ui/primitives/status-badge'
-import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
-import { useT } from '@open-mercato/shared/lib/i18n/context'
-
-type AvailabilityState = 'in_stock' | 'low_stock' | 'out_of_stock' | 'backorder' | 'preorder' | 'not_tracked'
-
-type AvailabilityItemResult = {
-  state: AvailabilityState
-  availableQuantity: number | null
-  canFulfil: boolean
-  leadTimeDays: number | null
-  releaseAt: string | null
-  isAuthoritative: boolean
-  policySourceId: string | null
-}
-
-type FieldTrace = { value: unknown; policySourceId: string | null }
-type PolicyTrace = Record<string, FieldTrace>
-
-type CheckResponse = {
-  availability?: AvailabilityItemResult | null
-  policyTrace?: PolicyTrace | null
-  error?: string
-}
-
-const STATE_VARIANTS: Record<AvailabilityState, StatusBadgeVariant> = {
-  in_stock: 'success',
-  low_stock: 'warning',
-  out_of_stock: 'error',
-  backorder: 'info',
-  preorder: 'info',
-  not_tracked: 'neutral',
-}
-
-const TRACE_FIELDS = [
-  'isStockManaged',
-  'allowBackorder',
-  'backorderLeadTimeDays',
-  'preorderReleaseAt',
-  'lowStockThreshold',
-  'minOrderQuantity',
-  'maxOrderQuantity',
-  'quantityIncrement',
-  'hideWhenOutOfStock',
-  'isActive',
-]
-
-function formatTraceValue(value: unknown, t: (key: string) => string): string {
-  if (value === null || value === undefined) return t('availability.policies.form.preview.notSet')
-  if (typeof value === 'boolean') return value ? t('common.yes') : t('common.no')
-  return String(value)
-}
-
-export default function AvailabilityCheckPage() {
-  const t = useT()
-  const [productId, setProductId] = React.useState('')
-  const [variantId, setVariantId] = React.useState('')
-  const [storeId, setStoreId] = React.useState('')
-  const [quantity, setQuantity] = React.useState('1')
-  const [isRunning, setIsRunning] = React.useState(false)
-  const [error, setError] = React.useState<string | null>(null)
-  const [result, setResult] = React.useState<CheckResponse | null>(null)
-
-  const runCheck = React.useCallback(async () => {
-    if (!productId.trim()) {
-      setError(t('availability.check.errors.productRequired'))
-      return
-    }
-    setIsRunning(true)
-    setError(null)
-    setResult(null)
-    try {
-      const call = await apiCall<CheckResponse>(
-        '/api/availability/check',
-        {
-          method: 'POST',
-          body: JSON.stringify({
-            productId: productId.trim(),
-            variantId: variantId.trim() || null,
-            storeId: storeId.trim() || null,
-            quantity: Number(quantity) > 0 ? Number(quantity) : 1,
-          }),
-        },
-        { fallback: null },
-      )
-      if (!call.ok) {
-        const errorPayload = call.result as { error?: string } | undefined
-        setError(typeof errorPayload?.error === 'string' ? errorPayload.error : t('availability.check.errors.failed'))
-        return
-      }
-      setResult(call.result ?? null)
-    } catch (e) {
-      setError(e instanceof Error ? e.message : t('availability.check.errors.failed'))
-    } finally {
-      setIsRunning(false)
-    }
-  }, [productId, variantId, storeId, quantity, t])
-
-  const availability = result?.availability ?? null
-  const policyTrace = result?.policyTrace ?? null
-
-  return (
-    <Page>
-      <PageBody>
-        <div
-          className="space-y-6"
-          onKeyDown={(event) => {
-            if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
-              event.preventDefault()
-              void runCheck()
-            }
-          }}
-        >
-          <h1 className="text-xl font-semibold">{t('availability.check.title')}</h1>
-          <div className="grid grid-cols-1 gap-4 rounded-md border p-4 sm:grid-cols-4">
-            <div className="space-y-1.5">
-              <Label htmlFor="availability-check-product-id">{t('availability.policies.form.field.productId')}</Label>
-              <Input
-                id="availability-check-product-id"
-                value={productId}
-                onChange={(e) => setProductId(e.target.value)}
-                autoFocus
-              />
-            </div>
-            <div className="space-y-1.5">
-              <Label htmlFor="availability-check-variant-id">{t('availability.policies.form.field.variantId')}</Label>
-              <Input id="availability-check-variant-id" value={variantId} onChange={(e) => setVariantId(e.target.value)} />
-            </div>
-            <div className="space-y-1.5">
-              <Label htmlFor="availability-check-store-id">{t('availability.policies.form.field.storeId')}</Label>
-              <Input id="availability-check-store-id" value={storeId} onChange={(e) => setStoreId(e.target.value)} />
-            </div>
-            <div className="space-y-1.5">
-              <Label htmlFor="availability-check-quantity">{t('availability.check.field.quantity')}</Label>
-              <Input
-                id="availability-check-quantity"
-                type="number"
-                min={1}
-                value={quantity}
-                onChange={(e) => setQuantity(e.target.value)}
-              />
-            </div>
-          </div>
-          <Button onClick={() => void runCheck()} disabled={isRunning}>
-            {isRunning ? t('availability.check.action.running') : t('availability.check.action.run')}
-          </Button>
-
-          {error && (
-            <div className="rounded-md border border-destructive/40 bg-destructive/10 p-4 text-sm text-destructive" data-testid="availability-check-error">
-              {error}
-            </div>
-          )}
-
-          {availability && (
-            <div className="space-y-4 rounded-md border p-4" data-testid="availability-check-result">
-              <div className="flex items-center gap-3">
-                <StatusBadge variant={STATE_VARIANTS[availability.state]}>{t(`availability.states.${availability.state}`)}</StatusBadge>
-                {!availability.isAuthoritative && (
-                  <span className="text-xs text-muted-foreground">{t('availability.check.advisoryNote')}</span>
-                )}
-              </div>
-              <dl className="grid grid-cols-1 gap-2 sm:grid-cols-3">
-                <div>
-                  <dt className="text-xs text-muted-foreground">{t('availability.check.result.availableQuantity')}</dt>
-                  <dd className="text-sm">{availability.availableQuantity ?? t('availability.policies.form.preview.notSet')}</dd>
-                </div>
-                <div>
-                  <dt className="text-xs text-muted-foreground">{t('availability.check.result.canFulfil')}</dt>
-                  <dd className="text-sm">{availability.canFulfil ? t('common.yes') : t('common.no')}</dd>
-                </div>
-                <div>
-                  <dt className="text-xs text-muted-foreground">{t('availability.check.result.policySourceId')}</dt>
-                  <dd className="text-sm">{availability.policySourceId ?? t('availability.policies.form.preview.moduleDefault')}</dd>
-                </div>
-                {availability.leadTimeDays != null && (
-                  <div>
-                    <dt className="text-xs text-muted-foreground">{t('availability.policies.form.field.backorderLeadTimeDays')}</dt>
-                    <dd className="text-sm">{availability.leadTimeDays}</dd>
-                  </div>
-                )}
-                {availability.releaseAt && (
-                  <div>
-                    <dt className="text-xs text-muted-foreground">{t('availability.policies.form.field.preorderReleaseAt')}</dt>
-                    <dd className="text-sm">{availability.releaseAt}</dd>
-                  </div>
-                )}
-              </dl>
-              {availability.state === 'not_tracked' && (
-                <p className="text-xs text-muted-foreground">{t('availability.check.notTrackedExplanation')}</p>
-              )}
-            </div>
-          )}
-
-          {policyTrace && (
-            <div className="rounded-md border bg-muted p-4" data-testid="availability-check-policy-trace">
-              <div className="mb-2 text-sm font-medium">{t('availability.policies.form.preview.title')}</div>
-              <dl className="grid grid-cols-1 gap-2 sm:grid-cols-2">
-                {TRACE_FIELDS.map((key) => {
-                  const field = policyTrace[key]
-                  const source = field?.policySourceId ?? t('availability.policies.form.preview.moduleDefault')
-                  return (
-                    <div key={key}>
-                      <dt className="text-xs text-muted-foreground">{t(`availability.policies.form.field.${key}`)}</dt>
-                      <dd className="text-xs">
-                        {formatTraceValue(field?.value, t)} <span className="text-muted-foreground">({source})</span>
-                      </dd>
-                    </div>
-                  )
-                })}
-              </dl>
-            </div>
-          )}
-        </div>
-      </PageBody>
-    </Page>
-  )
-}

package/src/modules/availability/backend/availability/policies/ResolutionPreviewPanel.tsx

@@ -1,106 +0,0 @@
-"use client"
-import * as React from 'react'
-import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
-import { useT } from '@open-mercato/shared/lib/i18n/context'
-
-type FieldTrace = { value: unknown; policySourceId: string | null }
-type PolicyTrace = Record<string, FieldTrace>
-
-type ResponsePayload = { policyTrace?: PolicyTrace }
-
-const TRACE_FIELDS: Array<{ key: string; labelKey: string }> = [
-  { key: 'isStockManaged', labelKey: 'availability.policies.form.field.isStockManaged' },
-  { key: 'allowBackorder', labelKey: 'availability.policies.form.field.allowBackorder' },
-  { key: 'backorderLeadTimeDays', labelKey: 'availability.policies.form.field.backorderLeadTimeDays' },
-  { key: 'preorderReleaseAt', labelKey: 'availability.policies.form.field.preorderReleaseAt' },
-  { key: 'lowStockThreshold', labelKey: 'availability.policies.form.field.lowStockThreshold' },
-  { key: 'minOrderQuantity', labelKey: 'availability.policies.form.field.minOrderQuantity' },
-  { key: 'maxOrderQuantity', labelKey: 'availability.policies.form.field.maxOrderQuantity' },
-  { key: 'quantityIncrement', labelKey: 'availability.policies.form.field.quantityIncrement' },
-  { key: 'hideWhenOutOfStock', labelKey: 'availability.policies.form.field.hideWhenOutOfStock' },
-  { key: 'isActive', labelKey: 'availability.policies.form.field.isActive' },
-]
-
-function formatValue(value: unknown, t: (key: string) => string): string {
-  if (value === null || value === undefined) return t('availability.policies.form.preview.notSet')
-  if (typeof value === 'boolean') return value ? t('common.yes') : t('common.no')
-  return String(value)
-}
-
-/**
- * Live "resolution-chain preview" — US-A2. Shows the currently PERSISTED
- * resolution for the (product, variant, store) target the admin is editing,
- * refetched (debounced) whenever the target changes. Does not simulate the
- * in-progress, unsaved field edits — see PLAN.md § Key design decisions.
- */
-export function ResolutionPreviewPanel({
-  productId,
-  variantId,
-  storeId,
-}: {
-  productId: string
-  variantId: string | null
-  storeId: string | null
-}) {
-  const t = useT()
-  const [trace, setTrace] = React.useState<PolicyTrace | null>(null)
-  const [isLoading, setIsLoading] = React.useState(false)
-
-  React.useEffect(() => {
-    if (!productId) {
-      setTrace(null)
-      return
-    }
-    let cancelled = false
-    const handle = setTimeout(() => {
-      setIsLoading(true)
-      const params = new URLSearchParams({ productId })
-      if (variantId) params.set('variantId', variantId)
-      if (storeId) params.set('storeId', storeId)
-      apiCall<ResponsePayload>(`/api/availability/policies/resolve-preview?${params.toString()}`, undefined, { fallback: null })
-        .then((call) => {
-          if (!cancelled && call.ok) setTrace(call.result?.policyTrace ?? null)
-        })
-        .finally(() => {
-          if (!cancelled) setIsLoading(false)
-        })
-    }, 300)
-    return () => {
-      cancelled = true
-      clearTimeout(handle)
-    }
-  }, [productId, variantId, storeId])
-
-  if (!productId) {
-    return (
-      <div className="rounded-md border bg-muted p-4 text-sm text-muted-foreground" data-testid="availability-resolution-preview">
-        {t('availability.policies.form.preview.enterProduct')}
-      </div>
-    )
-  }
-
-  return (
-    <div className="rounded-md border bg-muted p-4 text-sm" data-testid="availability-resolution-preview">
-      <div className="mb-2 font-medium">{t('availability.policies.form.preview.title')}</div>
-      {isLoading && !trace ? (
-        <div className="text-muted-foreground">{t('common.loading')}</div>
-      ) : (
-        <dl className="grid grid-cols-1 gap-2 sm:grid-cols-2">
-          {TRACE_FIELDS.map(({ key, labelKey }) => {
-            const field = trace?.[key]
-            const source = field?.policySourceId ?? t('availability.policies.form.preview.moduleDefault')
-            return (
-              <div key={key}>
-                <dt className="text-xs text-muted-foreground">{t(labelKey)}</dt>
-                <dd className="text-xs">
-                  {formatValue(field?.value, t)}{' '}
-                  <span className="text-muted-foreground">({source})</span>
-                </dd>
-              </div>
-            )
-          })}
-        </dl>
-      )}
-    </div>
-  )
-}

package/src/modules/availability/backend/availability/policies/ScopeFields.tsx

@@ -1,55 +0,0 @@
-"use client"
-import * as React from 'react'
-import { Input } from '@open-mercato/ui/primitives/input'
-import { Label } from '@open-mercato/ui/primitives/label'
-import { useT } from '@open-mercato/shared/lib/i18n/context'
-
-export type PolicyScope = {
-  productId: string
-  variantId: string
-  storeId: string
-}
-
-/**
- * Product/variant/store target fields, kept as controlled local state
- * (outside `CrudForm`'s own field list) so a value change can drive the live
- * resolution-chain preview immediately — `CrudForm` does not expose a
- * live-values callback. Rendered via `CrudForm`'s `contentHeader` slot.
- */
-export function ScopeFields({ value, onChange, disabled }: { value: PolicyScope; onChange: (next: PolicyScope) => void; disabled?: boolean }) {
-  const t = useT()
-  return (
-    <div className="grid grid-cols-1 gap-4 rounded-md border p-4 sm:grid-cols-3">
-      <div className="space-y-1.5">
-        <Label htmlFor="availability-policy-product-id">{t('availability.policies.form.field.productId')}</Label>
-        <Input
-          id="availability-policy-product-id"
-          value={value.productId}
-          disabled={disabled}
-          onChange={(e) => onChange({ ...value, productId: e.target.value.trim() })}
-          placeholder={t('availability.policies.form.field.productId.placeholder')}
-        />
-      </div>
-      <div className="space-y-1.5">
-        <Label htmlFor="availability-policy-variant-id">{t('availability.policies.form.field.variantId')}</Label>
-        <Input
-          id="availability-policy-variant-id"
-          value={value.variantId}
-          disabled={disabled}
-          onChange={(e) => onChange({ ...value, variantId: e.target.value.trim() })}
-          placeholder={t('availability.policies.form.field.variantId.placeholder')}
-        />
-      </div>
-      <div className="space-y-1.5">
-        <Label htmlFor="availability-policy-store-id">{t('availability.policies.form.field.storeId')}</Label>
-        <Input
-          id="availability-policy-store-id"
-          value={value.storeId}
-          disabled={disabled}
-          onChange={(e) => onChange({ ...value, storeId: e.target.value.trim() })}
-          placeholder={t('availability.policies.form.field.storeId.placeholder')}
-        />
-      </div>
-    </div>
-  )
-}

package/src/modules/availability/backend/availability/policies/[id]/page.meta.ts

@@ -1,8 +0,0 @@
-export const metadata = {
-  requireAuth: true,
-  requireFeatures: ['availability.policies.view'],
-  breadcrumb: [
-    { label: 'Availability Policies', labelKey: 'availability.policies.nav.title', href: '/backend/availability/policies' },
-    { label: 'Edit', labelKey: 'availability.policies.edit.title' },
-  ],
-}