@open-mercato/core 0.5.1-develop.2663.2c29774b5b → 0.5.1-develop.2681.c559bb2bc3

package/src/modules/catalog/i18n/en.json

@@ -408,6 +408,7 @@
   "catalog.products.edit.weight.unit": "Weight unit",
   "catalog.products.edit.weight.value": "Weight",
   "catalog.products.errors.handleExists": "Handle already in use.",
+  "catalog.products.errors.notFound": "Catalog product not found.",
   "catalog.products.errors.skuExists": "SKU already in use.",
   "catalog.products.errors.taxClassNotFound": "Tax class not found.",
   "catalog.products.filters.active": "Active",

package/src/modules/catalog/i18n/es.json

@@ -408,6 +408,7 @@
   "catalog.products.edit.weight.unit": "Unidad de peso",
   "catalog.products.edit.weight.value": "Peso",
   "catalog.products.errors.handleExists": "El identificador ya está en uso.",
+  "catalog.products.errors.notFound": "Catalog product not found.",
   "catalog.products.errors.skuExists": "El SKU ya está en uso.",
   "catalog.products.errors.taxClassNotFound": "Clase de impuesto no encontrada.",
   "catalog.products.filters.active": "Activo",

package/src/modules/catalog/i18n/pl.json

@@ -408,6 +408,7 @@
   "catalog.products.edit.weight.unit": "Jednostka wagi",
   "catalog.products.edit.weight.value": "Waga",
   "catalog.products.errors.handleExists": "Handle jest już używany.",
+  "catalog.products.errors.notFound": "Catalog product not found.",
   "catalog.products.errors.skuExists": "SKU jest już używany.",
   "catalog.products.errors.taxClassNotFound": "Nie znaleziono klasy podatkowej.",
   "catalog.products.filters.active": "Aktywne",

package/src/modules/customer_accounts/i18n/de.json

@@ -206,11 +206,13 @@
   "customer_accounts.search.badge.customerUser": "Kundenbenutzer",
   "customer_accounts.settings.back": "Kundenbenutzer",
   "customer_accounts.settings.demo_credentials.email": "Email",
+  "customer_accounts.settings.demo_credentials.note": "These credentials are only available if example data was seeded during setup.",
   "customer_accounts.settings.demo_credentials.password": "Password",
   "customer_accounts.settings.demo_credentials.role": "Role",
   "customer_accounts.settings.demo_credentials.title": "Demo Credentials",
   "customer_accounts.settings.portal_access.manage_orgs": "Manage Organizations",
   "customer_accounts.settings.portal_access.open_portal": "Open Portal",
+  "customer_accounts.settings.portal_access.slug_note": "The organization slug is auto-generated from the organization name. You can view and manage organizations in Directory → Organizations.",
   "customer_accounts.settings.portal_access.title": "Portal Access",
   "customer_accounts.settings.portal_access.url_label": "Portal URL pattern:",
   "customer_accounts.settings.quick_links.manage_roles": "Manage customer roles",

package/src/modules/customer_accounts/i18n/en.json

@@ -206,11 +206,13 @@
   "customer_accounts.search.badge.customerUser": "Customer user",
   "customer_accounts.settings.back": "Customer Users",
   "customer_accounts.settings.demo_credentials.email": "Email",
+  "customer_accounts.settings.demo_credentials.note": "These credentials are only available if example data was seeded during setup.",
   "customer_accounts.settings.demo_credentials.password": "Password",
   "customer_accounts.settings.demo_credentials.role": "Role",
   "customer_accounts.settings.demo_credentials.title": "Demo Credentials",
   "customer_accounts.settings.portal_access.manage_orgs": "Manage Organizations",
   "customer_accounts.settings.portal_access.open_portal": "Open Portal",
+  "customer_accounts.settings.portal_access.slug_note": "The organization slug is auto-generated from the organization name. You can view and manage organizations in Directory → Organizations.",
   "customer_accounts.settings.portal_access.title": "Portal Access",
   "customer_accounts.settings.portal_access.url_label": "Portal URL pattern:",
   "customer_accounts.settings.quick_links.manage_roles": "Manage customer roles",

package/src/modules/customer_accounts/i18n/es.json

@@ -206,11 +206,13 @@
   "customer_accounts.search.badge.customerUser": "Usuario de cliente",
   "customer_accounts.settings.back": "Usuarios de clientes",
   "customer_accounts.settings.demo_credentials.email": "Email",
+  "customer_accounts.settings.demo_credentials.note": "These credentials are only available if example data was seeded during setup.",
   "customer_accounts.settings.demo_credentials.password": "Password",
   "customer_accounts.settings.demo_credentials.role": "Role",
   "customer_accounts.settings.demo_credentials.title": "Demo Credentials",
   "customer_accounts.settings.portal_access.manage_orgs": "Manage Organizations",
   "customer_accounts.settings.portal_access.open_portal": "Open Portal",
+  "customer_accounts.settings.portal_access.slug_note": "The organization slug is auto-generated from the organization name. You can view and manage organizations in Directory → Organizations.",
   "customer_accounts.settings.portal_access.title": "Portal Access",
   "customer_accounts.settings.portal_access.url_label": "Portal URL pattern:",
   "customer_accounts.settings.quick_links.manage_roles": "Manage customer roles",

package/src/modules/customer_accounts/i18n/pl.json

@@ -206,11 +206,13 @@
   "customer_accounts.search.badge.customerUser": "Użytkownik klienta",
   "customer_accounts.settings.back": "Użytkownicy klientów",
   "customer_accounts.settings.demo_credentials.email": "Email",
+  "customer_accounts.settings.demo_credentials.note": "These credentials are only available if example data was seeded during setup.",
   "customer_accounts.settings.demo_credentials.password": "Password",
   "customer_accounts.settings.demo_credentials.role": "Role",
   "customer_accounts.settings.demo_credentials.title": "Demo Credentials",
   "customer_accounts.settings.portal_access.manage_orgs": "Manage Organizations",
   "customer_accounts.settings.portal_access.open_portal": "Open Portal",
+  "customer_accounts.settings.portal_access.slug_note": "The organization slug is auto-generated from the organization name. You can view and manage organizations in Directory → Organizations.",
   "customer_accounts.settings.portal_access.title": "Portal Access",
   "customer_accounts.settings.portal_access.url_label": "Portal URL pattern:",
   "customer_accounts.settings.quick_links.manage_roles": "Manage customer roles",

package/src/modules/customers/acl.ts

@@ -16,6 +16,8 @@ export const features = [
   { id: 'customers.widgets.new-deals', title: 'Use customer new deals widget', module: 'customers' },
   { id: 'customers.interactions.view', title: 'View interactions', module: 'customers' },
   { id: 'customers.interactions.manage', title: 'Manage interactions', module: 'customers' },
+  { id: 'customers.roles.view', title: 'View entity roles', module: 'customers' },
+  { id: 'customers.roles.manage', title: 'Manage entity roles', module: 'customers' },
 ]
 
 export default features

package/src/modules/customers/api/activities/route.ts

@@ -286,6 +286,8 @@ async function ensureCanonicalActivityBridge(
   await commandBus.execute('customers.interactions.create', {
     input: {
       id: activity.id,
+      tenantId: activity.tenantId,
+      organizationId: activity.organizationId,
       entityId,
       interactionType: activity.activityType,
       title: activity.subject ?? null,
@@ -564,6 +566,8 @@ export async function POST(request: Request): Promise<Response> {
     const commandBus = container.resolve('commandBus') as CommandBus
     const { result } = await commandBus.execute('customers.interactions.create', {
       input: {
+        tenantId: auth.tenantId,
+        organizationId: selectedOrganizationId ?? auth.orgId,
         entityId: parsed.entityId,
         interactionType: parsed.activityType,
         title: parsed.subject ?? null,

package/src/modules/customers/api/assignable-staff/route.ts

@@ -0,0 +1,250 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
+import { User } from '@open-mercato/core/modules/auth/data/entities'
+import { StaffTeam, StaffTeamMember } from '@open-mercato/core/modules/staff/data/entities'
+import { createPagedListResponseSchema } from '../openapi'
+import { resolveAuthActorId, resolveCustomersRequestContext } from '../../lib/interactionRequestContext'
+
+const querySchema = z
+  .object({
+    page: z.coerce.number().min(1).default(1),
+    pageSize: z.coerce.number().min(1).max(100).default(24),
+    search: z.string().optional(),
+  })
+  .passthrough()
+
+const itemSchema = z.object({
+  id: z.string().uuid(),
+  teamMemberId: z.string().uuid(),
+  userId: z.string().uuid(),
+  displayName: z.string(),
+  email: z.string().nullable().optional(),
+  teamName: z.string().nullable().optional(),
+  user: z
+    .object({
+      id: z.string().uuid(),
+      email: z.string().nullable().optional(),
+    })
+    .nullable()
+    .optional(),
+  team: z
+    .object({
+      id: z.string().uuid(),
+      name: z.string().nullable().optional(),
+    })
+    .nullable()
+    .optional(),
+})
+
+const errorSchema = z.object({ error: z.string() })
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['customers.roles.view'] },
+}
+
+async function canAccessAssignableStaff(
+  rbac: RbacService | undefined,
+  userId: string,
+  scope: { tenantId: string; organizationId: string },
+): Promise<boolean> {
+  if (!rbac) return false
+  if (
+    await rbac.userHasAllFeatures(userId, ['customers.roles.manage'], scope)
+  ) {
+    return true
+  }
+  return rbac.userHasAllFeatures(userId, ['customers.activities.manage'], scope)
+}
+
+export async function GET(request: Request) {
+  const { translate } = await resolveTranslations()
+  try {
+    const query = querySchema.parse(Object.fromEntries(new URL(request.url).searchParams))
+    const { container, em, auth, selectedOrganizationId } = await resolveCustomersRequestContext(request)
+
+    if (!selectedOrganizationId) {
+      throw new CrudHttpError(
+        400,
+        { error: translate('customers.errors.organization_required', 'Organization context is required') },
+      )
+    }
+
+    const actorId = resolveAuthActorId(auth)
+    const rbacService = container.resolve('rbacService') as RbacService | undefined
+    const scope = { tenantId: auth.tenantId, organizationId: selectedOrganizationId }
+    const hasAccess = await canAccessAssignableStaff(rbacService, actorId, scope)
+    if (!hasAccess) {
+      throw new CrudHttpError(
+        403,
+        {
+          error: translate(
+            'customers.assignableStaff.forbidden',
+            'Insufficient permissions to load assignable staff.',
+          ),
+        },
+      )
+    }
+
+    const normalizedSearch = query.search?.trim().toLowerCase() ?? ''
+
+    const members = await findWithDecryption(
+      em,
+      StaffTeamMember,
+      {
+        tenantId: auth.tenantId,
+        organizationId: selectedOrganizationId,
+        deletedAt: null,
+        isActive: true,
+      },
+      { orderBy: { displayName: 'asc' } },
+      scope,
+    )
+
+    const userIds = Array.from(
+      new Set(
+        members
+          .map((member) => (typeof member.userId === 'string' && member.userId.trim().length > 0 ? member.userId : null))
+          .filter((value): value is string => typeof value === 'string'),
+      ),
+    )
+    const teamIds = Array.from(
+      new Set(
+        members
+          .map((member) => (typeof member.teamId === 'string' && member.teamId.trim().length > 0 ? member.teamId : null))
+          .filter((value): value is string => typeof value === 'string'),
+      ),
+    )
+
+    const [users, teams] = await Promise.all([
+      userIds.length > 0
+        ? findWithDecryption(
+            em,
+            User,
+            {
+              id: { $in: userIds },
+              deletedAt: null,
+              tenantId: auth.tenantId,
+              organizationId: selectedOrganizationId,
+            },
+            undefined,
+            scope,
+          )
+        : Promise.resolve([]),
+      teamIds.length > 0
+        ? findWithDecryption(
+            em,
+            StaffTeam,
+            {
+              id: { $in: teamIds },
+              deletedAt: null,
+              tenantId: auth.tenantId,
+              organizationId: selectedOrganizationId,
+            },
+            undefined,
+            scope,
+          )
+        : Promise.resolve([]),
+    ])
+
+    const userById = new Map(
+      users.map((user) => [
+        user.id,
+        {
+          id: user.id,
+          email: user.email ?? null,
+        },
+      ]),
+    )
+    const teamById = new Map(
+      teams.map((team) => [
+        team.id,
+        {
+          id: team.id,
+          name: team.name ?? null,
+        },
+      ]),
+    )
+
+    const items = members
+      .filter((member) => typeof member.userId === 'string' && member.userId.trim().length > 0)
+      .map((member) => {
+        const userId = member.userId as string
+        const user = userById.get(userId) ?? { id: userId, email: null }
+        const team = member.teamId ? teamById.get(member.teamId) ?? null : null
+        return {
+          id: member.id,
+          teamMemberId: member.id,
+          userId,
+          displayName: member.displayName?.trim() || user.email || userId,
+          email: user.email,
+          teamName: team?.name ?? null,
+          user,
+          team,
+        }
+      })
+      .filter((item) => {
+        if (!normalizedSearch) return true
+        const haystack = [item.displayName, item.email, item.teamName]
+          .filter((value): value is string => typeof value === 'string' && value.length > 0)
+          .join(' ')
+          .toLowerCase()
+        return haystack.includes(normalizedSearch)
+      })
+
+    const deduped = Array.from(
+      items.reduce((acc, item) => {
+        if (!acc.has(item.userId)) {
+          acc.set(item.userId, item)
+        }
+        return acc
+      }, new Map<string, (typeof items)[number]>()),
+    ).map(([, item]) => item)
+
+    const start = (query.page - 1) * query.pageSize
+    return NextResponse.json({
+      items: deduped.slice(start, start + query.pageSize),
+      total: deduped.length,
+      page: query.page,
+      pageSize: query.pageSize,
+    })
+  } catch (error) {
+    if (error instanceof CrudHttpError) {
+      return NextResponse.json(error.body, { status: error.status })
+    }
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: translate('customers.errors.validationFailed', 'Validation failed') }, { status: 400 })
+    }
+    console.error('customers.assignable-staff.get failed', error)
+    return NextResponse.json({ error: translate('customers.errors.assignable_staff_load_failed', 'Failed to load assignable staff') }, { status: 500 })
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Customers',
+  summary: 'Assignable staff candidates',
+  methods: {
+    GET: {
+      summary: 'List staff members that can be assigned from customer flows',
+      query: querySchema,
+      description:
+        'Returns active staff members linked to auth users. Access requires either customers.roles.manage or customers.activities.manage.',
+      responses: [
+        {
+          status: 200,
+          description: 'Assignable staff members',
+          schema: createPagedListResponseSchema(itemSchema),
+        },
+      ],
+      errors: [
+        { status: 400, description: 'Invalid request', schema: errorSchema },
+        { status: 401, description: 'Unauthorized', schema: errorSchema },
+        { status: 403, description: 'Forbidden', schema: errorSchema },
+      ],
+    },
+  },
+}

package/src/modules/customers/api/companies/[id]/people/route.ts

@@ -0,0 +1,244 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { findOneWithDecryption, findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import {
+  CustomerEntity,
+  CustomerPersonCompanyLink,
+  CustomerPersonProfile,
+} from '../../../../data/entities'
+import { withActiveCustomerPersonCompanyLinkFilter } from '../../../../lib/personCompanyLinkTable'
+
+const paramsSchema = z.object({
+  id: z.string().uuid(),
+})
+
+const querySchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  pageSize: z.coerce.number().min(1).max(100).default(20),
+  search: z.string().optional(),
+  sort: z.enum(['name-asc', 'name-desc', 'recent']).default('name-asc'),
+})
+
+type CompanyPersonItem = {
+  id: string
+  displayName: string
+  primaryEmail: string | null
+  primaryPhone: string | null
+  status: string | null
+  lifecycleStage: string | null
+  jobTitle: string | null
+  department: string | null
+  createdAt: string
+  organizationId: string
+  temperature: string | null
+  source: string | null
+  linkedAt: string | null
+}
+
+function matchesSearch(item: CompanyPersonItem, query: string): boolean {
+  const normalized = query.trim().toLowerCase()
+  if (!normalized.length) return true
+  return [
+    item.displayName,
+    item.primaryEmail,
+    item.primaryPhone,
+    item.jobTitle,
+    item.department,
+    item.status,
+    item.lifecycleStage,
+    item.source,
+  ]
+    .filter((value): value is string => typeof value === 'string' && value.length > 0)
+    .some((value) => value.toLowerCase().includes(normalized))
+}
+
+function sortItems(items: CompanyPersonItem[], sort: 'name-asc' | 'name-desc' | 'recent'): CompanyPersonItem[] {
+  if (sort === 'recent') {
+    return [...items].sort((left, right) => {
+      const leftTimestamp = left.linkedAt ? new Date(left.linkedAt).getTime() : new Date(left.createdAt).getTime()
+      const rightTimestamp = right.linkedAt ? new Date(right.linkedAt).getTime() : new Date(right.createdAt).getTime()
+      if (leftTimestamp === rightTimestamp) return left.displayName.localeCompare(right.displayName)
+      return rightTimestamp - leftTimestamp
+    })
+  }
+
+  return [...items].sort((left, right) => {
+    const compare = left.displayName.localeCompare(right.displayName, undefined, { sensitivity: 'base' })
+    return sort === 'name-asc' ? compare : -compare
+  })
+}
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['customers.companies.view'] },
+}
+
+export async function GET(req: Request, ctx: { params?: { id?: string } }) {
+  const { translate } = await resolveTranslations()
+  try {
+    const { id } = paramsSchema.parse({ id: ctx.params?.id })
+    const auth = await getAuthFromRequest(req)
+    if (!auth?.tenantId) throw new CrudHttpError(401, { error: 'Unauthorized' })
+
+    const query = querySchema.parse({
+      page: new URL(req.url).searchParams.get('page') ?? undefined,
+      pageSize: new URL(req.url).searchParams.get('pageSize') ?? undefined,
+      search: new URL(req.url).searchParams.get('search') ?? undefined,
+      sort: new URL(req.url).searchParams.get('sort') ?? undefined,
+    })
+
+    const container = await createRequestContainer()
+    const scope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+    const em = (container.resolve('em') as EntityManager).fork()
+    const decryptionScope = {
+      tenantId: auth.tenantId,
+      organizationId: scope?.selectedId ?? auth.orgId ?? null,
+    }
+
+    const company = await findOneWithDecryption(
+      em,
+      CustomerEntity,
+      { id, kind: 'company', tenantId: auth.tenantId, deletedAt: null },
+      {},
+      decryptionScope,
+    )
+    if (!company) {
+      throw new CrudHttpError(404, { error: translate('customers.errors.company_not_found', 'Company not found') })
+    }
+
+    const allowedOrgIds = new Set<string>()
+    if (scope?.filterIds?.length) scope.filterIds.forEach((entry) => allowedOrgIds.add(entry))
+    else if (auth.orgId) allowedOrgIds.add(auth.orgId)
+    if (allowedOrgIds.size > 0 && company.organizationId && !allowedOrgIds.has(company.organizationId)) {
+      throw new CrudHttpError(403, { error: translate('customers.errors.access_denied', 'Access denied') })
+    }
+
+    const entityScope = { tenantId: auth.tenantId, organizationId: company.organizationId }
+    const linkWhere = await withActiveCustomerPersonCompanyLinkFilter(
+      em,
+      {
+        company: company.id,
+        tenantId: company.tenantId,
+        organizationId: company.organizationId,
+      },
+      'customers.companies.people.GET',
+    )
+    const links = await findWithDecryption(
+      em,
+      CustomerPersonCompanyLink,
+      linkWhere,
+      { populate: ['person'] },
+      entityScope,
+    )
+
+    const personIds = links
+      .map((link) => link.person?.id)
+      .filter((personId): personId is string => typeof personId === 'string' && personId.length > 0)
+
+    const profiles = personIds.length > 0
+      ? await findWithDecryption(
+          em,
+          CustomerPersonProfile,
+          {
+            entity: { $in: personIds },
+            tenantId: company.tenantId,
+            organizationId: company.organizationId,
+          },
+          {},
+          entityScope,
+        )
+      : []
+    const profileByPersonId = new Map(
+      profiles.map((profile) => [(profile.entity as { id: string }).id, profile]),
+    )
+
+    const items = links
+      .map((link) => {
+        const person = link.person
+        if (!person?.id) return null
+        const profile = profileByPersonId.get(person.id) ?? null
+        return {
+          id: person.id,
+          displayName: person.displayName ?? person.primaryEmail ?? person.id,
+          primaryEmail: person.primaryEmail ?? null,
+          primaryPhone: person.primaryPhone ?? null,
+          status: person.status ?? null,
+          lifecycleStage: person.lifecycleStage ?? null,
+          jobTitle: profile?.jobTitle ?? null,
+          department: profile?.department ?? null,
+          createdAt: person.createdAt.toISOString(),
+          organizationId: person.organizationId,
+          temperature: person.temperature ?? null,
+          source: person.source ?? null,
+          linkedAt: link.createdAt ? link.createdAt.toISOString() : null,
+        } satisfies CompanyPersonItem
+      })
+      .filter((item): item is CompanyPersonItem => item !== null)
+
+    const filtered = query.search?.trim().length ? items.filter((item) => matchesSearch(item, query.search ?? '')) : items
+    const sorted = sortItems(filtered, query.sort)
+    const total = sorted.length
+    const totalPages = Math.max(1, Math.ceil(total / query.pageSize))
+    const page = Math.min(query.page, totalPages)
+    const start = (page - 1) * query.pageSize
+
+    return NextResponse.json({
+      items: sorted.slice(start, start + query.pageSize),
+      total,
+      page,
+      pageSize: query.pageSize,
+      totalPages,
+    })
+  } catch (error) {
+    if (error instanceof CrudHttpError) {
+      return NextResponse.json(error.body, { status: error.status })
+    }
+    console.error('[customers.companies.people.GET]', error)
+    return NextResponse.json({ error: translate('customers.errors.company_people_load_failed', 'Failed to load linked people') }, { status: 500 })
+  }
+}
+
+const companyPeopleItemSchema = z.object({
+  id: z.string().uuid(),
+  displayName: z.string(),
+  primaryEmail: z.string().nullable(),
+  primaryPhone: z.string().nullable(),
+  status: z.string().nullable(),
+  lifecycleStage: z.string().nullable(),
+  jobTitle: z.string().nullable(),
+  department: z.string().nullable(),
+  createdAt: z.string(),
+  organizationId: z.string().uuid().nullable(),
+  temperature: z.string().nullable(),
+  source: z.string().nullable(),
+  linkedAt: z.string().nullable(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Customers',
+  methods: {
+    GET: {
+      summary: 'List linked people for a company',
+      query: querySchema,
+      responses: [
+        {
+          status: 200,
+          description: 'Paginated linked people',
+          schema: z.object({
+            items: z.array(companyPeopleItemSchema),
+            total: z.number().int().nonnegative(),
+            page: z.number().int().min(1),
+            pageSize: z.number().int().min(1),
+            totalPages: z.number().int().min(1),
+          }),
+        },
+      ],
+    },
+  },
+}

package/src/modules/customers/api/companies/[id]/roles/route.ts

@@ -0,0 +1,15 @@
+import { buildEntityRolesOpenApi, createEntityRolesHandlers } from '../../../../api/entity-roles-factory'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['customers.roles.view'] },
+  POST: { requireAuth: true, requireFeatures: ['customers.roles.manage'] },
+  PUT: { requireAuth: true, requireFeatures: ['customers.roles.manage'] },
+  DELETE: { requireAuth: true, requireFeatures: ['customers.roles.manage'] },
+}
+export const openApi = buildEntityRolesOpenApi('company')
+
+const handlers = createEntityRolesHandlers('company')
+export const GET = handlers.GET
+export const POST = handlers.POST
+export const PUT = handlers.PUT
+export const DELETE = handlers.DELETE