@open-mercato/core 0.6.4-develop.4382.1.6b4f656b77 → 0.6.4

package/src/modules/query_index/subscribers/upsert_one.ts

@@ -1,12 +1,20 @@
 import { recordIndexerError } from '@open-mercato/shared/lib/indexers/error-log'
-import { upsertIndexRow } from '../lib/indexer'
+import { upsertIndexRow, reindexSearchTokensForRecord } from '../lib/indexer'
 import { applyCoverageAdjustments, createCoverageAdjustments } from '../lib/coverage'
 import { loadQueryIndexRowScope, resolveQueryIndexRecordScope } from '../lib/subscriber-scope'
 
 export const metadata = { event: 'query_index.upsert_one', persistent: false }
 
 export default async function handle(payload: any, ctx: { resolve: <T=any>(name: string) => T }) {
-  const em = ctx.resolve<any>('em')
+  // Run index maintenance on a FORKED EntityManager (fresh identity map + UnitOfWork)
+  // so it can never disturb the originating CRUD write's `em`. The data engine awaits
+  // this emit for read-your-writes consistency, which means the subscriber runs
+  // synchronously on the request `em`; sharing it would let our `em.find` / raw
+  // `getKysely()` queries reset the caller's UoW change-tracking and silently drop the
+  // caller's pending write (e.g. the deal's `setCustomFields` insert). The fork reads
+  // the same committed DB rows via the shared connection but keeps its own UoW.
+  const baseEm = ctx.resolve<any>('em')
+  const em = typeof baseEm?.fork === 'function' ? baseEm.fork() : baseEm
   const entityType = String(payload?.entityType || '')
   const recordId = String(payload?.recordId || '')
   if (!entityType || !recordId) return
@@ -28,14 +36,18 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
     organizationId = resolvedScope.organizationId
     tenantId = resolvedScope.tenantId
 
+    const searchTokenDoc = typeof payload?.searchTokenDoc === 'object' && payload.searchTokenDoc && !Array.isArray(payload.searchTokenDoc)
+      ? (payload.searchTokenDoc as Record<string, unknown>)
+      : null
+    // Update the projection row synchronously so list reads (`customValues`) are
+    // consistent the moment the write returns; defer the heavy search-token rebuild.
     const result = await upsertIndexRow(em, {
       entityType,
       recordId,
       organizationId,
       tenantId,
-      searchTokenDoc: typeof payload?.searchTokenDoc === 'object' && payload.searchTokenDoc && !Array.isArray(payload.searchTokenDoc)
-        ? payload.searchTokenDoc
-        : null,
+      searchTokenDoc,
+      deferSearchTokens: true,
     })
     if (!suppressCoverage) {
       const doc = result.doc
@@ -84,16 +96,33 @@ export default async function handle(payload: any, ctx: { resolve: <T=any>(name:
         } catch {}
       }
     }
-    // Kick off secondary pass (vectorize) asynchronously
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('query_index.vectorize_one', { entityType, recordId, organizationId, tenantId })
-    } catch {}
-    // Emit search indexing event
-    try {
-      const bus = ctx.resolve<any>('eventBus')
-      await bus.emitEvent('search.index_record', { entityId: entityType, recordId, organizationId, tenantId })
-    } catch {}
+    // Defer the heavy, eventually-consistent tail: search-token rebuild + vectorize +
+    // fulltext indexing. The data engine awaits this subscriber for projection
+    // consistency, so this work runs fire-and-forget to keep write latency bounded.
+    const deferredScope = { entityType, recordId, organizationId, tenantId }
+    const resolvedDoc = result.doc
+    void (async () => {
+      try {
+        await reindexSearchTokensForRecord(em, { ...deferredScope, doc: resolvedDoc, searchTokenDoc })
+        const bus = ctx.resolve<any>('eventBus')
+        await bus.emitEvent('query_index.vectorize_one', deferredScope)
+        await bus.emitEvent('search.index_record', { entityId: entityType, recordId, organizationId, tenantId })
+      } catch (error) {
+        await recordIndexerError(
+          { em },
+          {
+            source: 'query_index',
+            handler: 'event:query_index.upsert_one:search_tokens',
+            error,
+            entityType,
+            recordId,
+            tenantId: tenantId ?? null,
+            organizationId: organizationId ?? null,
+            payload,
+          },
+        ).catch(() => {})
+      }
+    })()
   } catch (error) {
     await recordIndexerError(
       { em },

package/src/modules/resources/backend/resources/resource-types/[id]/edit/page.tsx

@@ -3,7 +3,7 @@
 import * as React from 'react'
 import { useRouter } from 'next/navigation'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
-import { ErrorMessage } from '@open-mercato/ui/backend/detail'
+import { ErrorMessage, RecordNotFoundState } from '@open-mercato/ui/backend/detail'
 import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
 import { updateCrud, deleteCrud } from '@open-mercato/ui/backend/utils/crud'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
@@ -22,6 +22,7 @@ export default function ResourcesResourceTypeEditPage({ params }: { params?: { i
   const [initialValues, setInitialValues] = React.useState<ResourceTypeFormValues | null>(null)
   const [loading, setLoading] = React.useState(true)
   const [error, setError] = React.useState<string | null>(null)
+  const [isNotFound, setIsNotFound] = React.useState(false)
   const [resourceCount, setResourceCount] = React.useState(0)
 
   React.useEffect(() => {
@@ -30,6 +31,7 @@ export default function ResourcesResourceTypeEditPage({ params }: { params?: { i
     async function load() {
       setLoading(true)
       setError(null)
+      setIsNotFound(false)
       try {
         const payload = await readApiResultOrThrow<ResourceTypesResponse>(
           `/api/resources/resource-types?ids=${encodeURIComponent(resourceTypeId)}&page=1&pageSize=1`,
@@ -37,7 +39,10 @@ export default function ResourcesResourceTypeEditPage({ params }: { params?: { i
           { errorMessage: t('resources.resourceTypes.errors.load', 'Failed to load resource types.') },
         )
         const item = Array.isArray(payload.items) ? payload.items[0] : null
-        if (!item) throw new Error(t('resources.resourceTypes.errors.notFound', 'Resource type not found.'))
+        if (!item) {
+          if (!cancelled) setIsNotFound(true)
+          return
+        }
         if (!cancelled) {
           const customValues = extractCustomFieldValues(item)
           setInitialValues({
@@ -54,8 +59,13 @@ export default function ResourcesResourceTypeEditPage({ params }: { params?: { i
                 ? item.appearanceColor
                 : typeof item.appearance_color === 'string'
                   ? item.appearance_color
-                  : null,
+                : null,
             },
+            updatedAt: typeof item.updatedAt === 'string'
+              ? item.updatedAt
+              : typeof item.updated_at === 'string'
+                ? item.updated_at
+                : null,
             ...customValues,
           })
           setResourceCount(typeof item.resourceCount === 'number'
@@ -98,12 +108,27 @@ export default function ResourcesResourceTypeEditPage({ params }: { params?: { i
     router.push('/backend/resources/resource-types')
   }, [resourceCount, resourceTypeId, router, t])
 
+  if (isNotFound) {
+    return (
+      <Page>
+        <PageBody>
+          <RecordNotFoundState
+            label={t('resources.resourceTypes.errors.notFound', 'Resource type not found.')}
+            backHref="/backend/resources/resource-types"
+            backLabel={t('resources.resourceTypes.actions.backToList', 'Back to resource types')}
+          />
+        </PageBody>
+      </Page>
+    )
+  }
+
   return (
     <Page>
       <PageBody>
         {error ? (
           <ErrorMessage label={error} />
         ) : null}
+        {/* optimistic-lock: ResourceTypeCrudForm forwards optimisticLockUpdatedAt from initialValues.updatedAt (auto-derives the header on save + delete). */}
         <ResourceTypeCrudForm
           mode="edit"
           initialValues={initialValues ?? { id: resourceTypeId, name: '', description: '', appearance: { icon: null, color: null } }}

package/src/modules/resources/backend/resources/resource-types/page.tsx

@@ -10,8 +10,9 @@ import { DataTable, withDataTableNamespaces } from '@open-mercato/ui/backend/Dat
 import { Button } from '@open-mercato/ui/primitives/button'
 import { RowActions } from '@open-mercato/ui/backend/RowActions'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
-import { readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { readApiResultOrThrow, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
 import { deleteCrud } from '@open-mercato/ui/backend/utils/crud'
+import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
 import { renderDictionaryColor, renderDictionaryIcon } from '@open-mercato/core/modules/dictionaries/components/dictionaryAppearance'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import { Package } from 'lucide-react'
@@ -228,7 +229,10 @@ export default function ResourcesResourceTypesPage() {
     })
     if (!confirmed) return
     try {
-      await deleteCrud('resources/resource-types', entry.id, { errorMessage: translations.errors.delete })
+      const headers = buildOptimisticLockHeader(entry.updatedAt)
+      await withScopedApiRequestHeaders(headers, () => (
+        deleteCrud('resources/resource-types', entry.id, { errorMessage: translations.errors.delete })
+      ))
       flash(translations.messages.deleted, 'success')
       handleRefresh()
     } catch (error) {
@@ -314,4 +318,3 @@ function mapApiResourceType(item: Record<string, unknown>): ResourceTypeRow {
       : 0
   return withDataTableNamespaces({ id, name, description, appearanceIcon, appearanceColor, updatedAt, resourceCount }, item)
 }
-

package/src/modules/resources/backend/resources/resources/[id]/page.tsx

@@ -5,7 +5,8 @@ import { useRouter, useSearchParams } from 'next/navigation'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { FormHeader } from '@open-mercato/ui/backend/forms'
 import { Button } from '@open-mercato/ui/primitives/button'
-import { apiCallOrThrow, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { apiCallOrThrow, readApiResultOrThrow, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
+import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
 import { collectCustomFieldValues } from '@open-mercato/ui/backend/utils/customFieldValues'
 import { createCrudFormError } from '@open-mercato/ui/backend/utils/serverErrors'
 import { updateCrud, deleteCrud } from '@open-mercato/ui/backend/utils/crud'
@@ -84,11 +85,24 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
   const searchParams = useSearchParams()
   const [initialValues, setInitialValues] = React.useState<Record<string, unknown> | null>(null)
   const [isNotFound, setIsNotFound] = React.useState(false)
+  // Capture the record (incl. its optimistic-lock `updatedAt`) exactly ONCE per
+  // resource. The load effect's deps include identity-unstable values (`t`,
+  // `resolveFieldsetCode`), so without this guard a re-render would re-fetch and
+  // overwrite `initialValues.updatedAt` with a newer server value mid-edit —
+  // silently defeating optimistic locking (a concurrent change would no longer be
+  // detected) and making the conflict flaky.
+  const loadedResourceIdRef = React.useRef<string | null>(null)
   const [tags, setTags] = React.useState<TagOption[]>([])
   const [activeTab, setActiveTab] = React.useState<'details' | 'availability'>('details')
   const [activeDetailTab, setActiveDetailTab] = React.useState<'notes' | 'activities'>('notes')
   const [sectionAction, setSectionAction] = React.useState<SectionAction | null>(null)
   const [availabilityRuleSetId, setAvailabilityRuleSetId] = React.useState<string | null>(null)
+  const [selectedCapacityUnit, setSelectedCapacityUnit] = React.useState<{
+    value: string
+    label: string
+    color?: string | null
+    icon?: string | null
+  } | null>(null)
   const [activityDictionaryId, setActivityDictionaryId] = React.useState<string | null>(null)
   const [activityTypeEntries, setActivityTypeEntries] = React.useState<DictionaryEntryOption[]>([])
   const flashShownRef = React.useRef(false)
@@ -407,11 +421,22 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
     [createTag, handleTagsSave, loadTagOptions, t, tagLabels, tags],
   )
 
-  const formConfig = useResourcesResourceFormConfig({ tagsSection })
+  const formConfig = useResourcesResourceFormConfig({
+    tagsSection,
+    selectedResourceTypeId:
+      typeof initialValues?.resourceTypeId === 'string' ? initialValues.resourceTypeId : null,
+    selectedCapacityUnit:
+      typeof initialValues?.capacityUnitValue === 'string' && initialValues.capacityUnitValue.length > 0
+        ? selectedCapacityUnit
+        : null,
+  })
   const { resourceTypesLoaded, resolveFieldsetCode } = formConfig
 
   React.useEffect(() => {
     if (!resourceId || !resourceTypesLoaded) return
+    // Load once per resource — never re-fetch (and thereby refresh the captured
+    // optimistic-lock token) on subsequent re-renders. See loadedResourceIdRef.
+    if (loadedResourceIdRef.current === resourceId) return
     setIsNotFound(false)
     let cancelled = false
     async function loadResource() {
@@ -428,6 +453,7 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
           return
         }
         if (!cancelled) {
+          loadedResourceIdRef.current = resourceId ?? null
           const customValues = extractCustomFieldEntries(resource)
           setTags(Array.isArray(resource.tags) ? resource.tags : [])
           setAvailabilityRuleSetId(
@@ -437,6 +463,19 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
                 ? resource.availability_rule_set_id
                 : null,
           )
+          setSelectedCapacityUnit(
+            typeof resource.capacityUnitValue === 'string' && resource.capacityUnitValue.length > 0
+              ? {
+                  value: resource.capacityUnitValue,
+                  label:
+                    typeof resource.capacityUnitName === 'string' && resource.capacityUnitName.length > 0
+                      ? resource.capacityUnitName
+                      : resource.capacityUnitValue,
+                  color: typeof resource.capacityUnitColor === 'string' ? resource.capacityUnitColor : null,
+                  icon: typeof resource.capacityUnitIcon === 'string' ? resource.capacityUnitIcon : null,
+                }
+              : null,
+          )
           setInitialValues({
             id: resource.id,
             name: resource.name,
@@ -446,6 +485,12 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
             capacityUnitValue: resource.capacityUnitValue ?? '',
             appearance: { icon: resource.appearanceIcon ?? null, color: resource.appearanceColor ?? null },
             isActive: resource.isActive ?? true,
+            updatedAt:
+              typeof resource.updatedAt === 'string'
+                ? resource.updatedAt
+                : typeof resource.updated_at === 'string'
+                  ? resource.updated_at
+                  : null,
             customFieldsetCode: resource.resourceTypeId
               ? resolveFieldsetCode(resource.resourceTypeId)
               : RESOURCES_RESOURCE_FIELDSET_DEFAULT,
@@ -472,12 +517,20 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
 
   const handleRulesetChange = React.useCallback(async (nextId: string | null) => {
     if (!resourceId) return
-    await updateCrud('resources/resources', { id: resourceId, availabilityRuleSetId: nextId }, {
+    const updateSchedule = () => updateCrud('resources/resources', { id: resourceId, availabilityRuleSetId: nextId }, {
       errorMessage: t('resources.resources.availability.ruleset.updateError', 'Failed to update schedule.'),
     })
+    const resourceOptimisticLockHeader = buildOptimisticLockHeader(
+      typeof initialValues?.updatedAt === 'string' ? initialValues.updatedAt : null,
+    )
+    if (Object.keys(resourceOptimisticLockHeader).length > 0) {
+      await withScopedApiRequestHeaders(resourceOptimisticLockHeader, updateSchedule)
+    } else {
+      await updateSchedule()
+    }
     setAvailabilityRuleSetId(nextId)
     flash(t('resources.resources.availability.ruleset.updateSuccess', 'Schedule updated.'), 'success')
-  }, [resourceId, t])
+  }, [initialValues?.updatedAt, resourceId, t])
 
   const resourceTitle =
     typeof initialValues?.name === 'string' && initialValues.name.trim().length > 0
@@ -647,6 +700,11 @@ export default function ResourcesResourceDetailPage({ params }: { params?: { id?
                   successRedirect="/backend/resources/resources"
                   formConfig={formConfig}
                   initialValues={initialValues ?? undefined}
+                  optimisticLockUpdatedAt={
+                    typeof initialValues?.updatedAt === 'string'
+                      ? initialValues.updatedAt
+                      : null
+                  }
                   onSubmit={handleSubmit}
                   onDelete={handleDelete}
                   isLoading={!initialValues}

package/src/modules/resources/backend/resources/resources/page.tsx

@@ -6,11 +6,13 @@ import { usePathname, useRouter, useSearchParams } from 'next/navigation'
 import type { ColumnDef } from '@tanstack/react-table'
 import { Page, PageBody } from '@open-mercato/ui/backend/Page'
 import { DataTable, withDataTableNamespaces } from '@open-mercato/ui/backend/DataTable'
+import { ListEmptyState } from '@open-mercato/ui/backend/filters/ListEmptyState'
 import { RowActions } from '@open-mercato/ui/backend/RowActions'
 import { Button } from '@open-mercato/ui/primitives/button'
 import { BooleanIcon } from '@open-mercato/ui/backend/ValueIcons'
-import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { apiCall, withScopedApiRequestHeaders } from '@open-mercato/ui/backend/utils/apiCall'
 import { deleteCrud } from '@open-mercato/ui/backend/utils/crud'
+import { buildOptimisticLockHeader } from '@open-mercato/ui/backend/utils/optimisticLock'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import type { FilterDef, FilterOption, FilterValues } from '@open-mercato/ui/backend/FilterOverlay'
 import type { TagOption } from '@open-mercato/ui/backend/detail'
@@ -31,6 +33,7 @@ type ResourceRow = {
   isActive: boolean
   appearanceIcon?: string | null
   appearanceColor?: string | null
+  updatedAt?: string | null
 }
 
 type ResourceTypeRow = {
@@ -349,9 +352,12 @@ export default function ResourcesResourcesPage() {
     })
     if (!confirmed) return
     try {
-      await deleteCrud('resources/resources', row.id, {
-        errorMessage: t('resources.resources.list.error.delete', 'Failed to delete resource.'),
-      })
+      const headers = buildOptimisticLockHeader(row.updatedAt)
+      await withScopedApiRequestHeaders(headers, () => (
+        deleteCrud('resources/resources', row.id, {
+          errorMessage: t('resources.resources.list.error.delete', 'Failed to delete resource.'),
+        })
+      ))
       flash(t('resources.resources.list.flash.deleted', 'Resource deleted.'), 'success')
       setPage(1)
       router.refresh()
@@ -498,6 +504,13 @@ export default function ResourcesResourcesPage() {
             if (row.rowKind !== 'resource') return
             router.push(`/backend/resources/resources/${encodeURIComponent(row.id)}`)
           } : undefined}
+          emptyState={(
+            <ListEmptyState
+              entityName={t('resources.resources.page.title', 'Resources')}
+              createHref="/backend/resources/resources/create"
+              createLabel={t('resources.resources.list.actions.create', 'New resource')}
+            />
+          )}
           pagination={{ page, pageSize: PAGE_SIZE, total, totalPages, onPageChange: setPage }}
           isLoading={isLoading}
         />
@@ -536,6 +549,11 @@ function mapApiResource(item: Record<string, unknown>): ResourceRow {
       ? item.appearance_color
       : null
   const tags = Array.isArray(item.tags) ? item.tags as TagOption[] : []
+  const updatedAt = typeof item.updatedAt === 'string'
+    ? item.updatedAt
+    : typeof item.updated_at === 'string'
+      ? item.updated_at
+      : null
   return withDataTableNamespaces({
     id,
     name,
@@ -545,5 +563,6 @@ function mapApiResource(item: Record<string, unknown>): ResourceRow {
     isActive,
     appearanceIcon,
     appearanceColor,
+    updatedAt,
   }, item)
 }

package/src/modules/resources/commands/activities.ts

@@ -21,6 +21,7 @@ import {
   buildCustomFieldResetMap,
   type CustomFieldChangeSet,
 } from '@open-mercato/shared/lib/commands/customFieldSnapshots'
+import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
 import { ResourcesResourceActivity } from '../data/entities'
 import {
   resourcesResourceActivityCreateSchema,
@@ -192,6 +193,72 @@ const createActivityCommand: CommandHandler<ResourcesResourceActivityCreateInput
       await em.flush()
     }
   },
+  redo: async ({ logEntry, ctx }) => {
+    const after = resolveRedoSnapshot<ActivitySnapshot>(logEntry)
+    if (!after) {
+      throw new CrudHttpError(400, { error: '[internal] redo snapshot unavailable for activity create' })
+    }
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    const resource = await requireResource(em, after.activity.resourceId, 'Resource not found')
+    let activity = await em.findOne(ResourcesResourceActivity, { id: after.activity.id })
+    if (!activity) {
+      activity = em.create(ResourcesResourceActivity, {
+        id: after.activity.id,
+        organizationId: after.activity.organizationId,
+        tenantId: after.activity.tenantId,
+        resource,
+        activityType: after.activity.activityType,
+        subject: after.activity.subject,
+        body: after.activity.body,
+        occurredAt: after.activity.occurredAt,
+        authorUserId: after.activity.authorUserId,
+        appearanceIcon: after.activity.appearanceIcon,
+        appearanceColor: after.activity.appearanceColor,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      })
+      em.persist(activity)
+    } else {
+      activity.resource = resource
+      activity.activityType = after.activity.activityType
+      activity.subject = after.activity.subject
+      activity.body = after.activity.body
+      activity.occurredAt = after.activity.occurredAt
+      activity.authorUserId = after.activity.authorUserId
+      activity.appearanceIcon = after.activity.appearanceIcon
+      activity.appearanceColor = after.activity.appearanceColor
+    }
+    await em.flush()
+
+    const de = (ctx.container.resolve('dataEngine') as DataEngine)
+    await emitCrudSideEffects({
+      dataEngine: de,
+      action: 'created',
+      entity: activity,
+      identifiers: {
+        id: activity.id,
+        organizationId: activity.organizationId,
+        tenantId: activity.tenantId,
+      },
+      events: resourcesResourceActivityCrudEvents,
+      indexer: activityCrudIndexer,
+    })
+
+    const resetValues = buildCustomFieldResetMap(after.custom, undefined)
+    if (Object.keys(resetValues).length) {
+      await setCustomFieldsIfAny({
+        dataEngine: de,
+        entityId: ACTIVITY_ENTITY_ID,
+        recordId: activity.id,
+        organizationId: activity.organizationId,
+        tenantId: activity.tenantId,
+        values: resetValues,
+        notify: false,
+      })
+    }
+
+    return { activityId: activity.id, authorUserId: activity.authorUserId ?? null }
+  },
 }
 
 const updateActivityCommand: CommandHandler<ResourcesResourceActivityUpdateInput, { activityId: string }> = {

package/src/modules/resources/commands/comments.ts

@@ -14,6 +14,7 @@ import {
   type ResourcesResourceCommentUpdateInput,
 } from '../data/validators'
 import { resourcesResourceCommentCrudEvents } from '../lib/crud'
+import { makeCreateRedo } from '@open-mercato/shared/lib/commands/redo'
 import { ensureOrganizationScope, ensureTenantScope, extractUndoPayload, requireResource } from './shared'
 import { E } from '#generated/entities.ids.generated'
 
@@ -132,6 +133,25 @@ const createCommentCommand: CommandHandler<
       await em.flush()
     }
   },
+  redo: makeCreateRedo<ResourcesResourceComment, CommentSnapshot, ResourcesResourceCommentCreateInput, { commentId: string; authorUserId: string | null }>({
+    entityClass: ResourcesResourceComment,
+    seedFromSnapshot: (after) => ({
+      id: after.id,
+      organizationId: after.organizationId,
+      tenantId: after.tenantId,
+      body: after.body,
+      authorUserId: after.authorUserId,
+      appearanceIcon: after.appearanceIcon,
+      appearanceColor: after.appearanceColor,
+    }),
+    beforeRestore: async ({ em, snapshot }) => {
+      const resource = await requireResource(em, snapshot.resourceId, 'Resource not found')
+      return { resource }
+    },
+    buildResult: (entity) => ({ commentId: entity.id, authorUserId: entity.authorUserId ?? null }),
+    events: resourcesResourceCommentCrudEvents,
+    indexer: commentCrudIndexer,
+  }),
 }
 
 const updateCommentCommand: CommandHandler<ResourcesResourceCommentUpdateInput, { commentId: string }> = {

package/src/modules/resources/commands/resource-types.ts

@@ -16,6 +16,7 @@ import {
   type ResourcesResourceTypeUpdateInput,
 } from '../data/validators'
 import { resourcesResourceTypeCrudEvents } from '../lib/crud'
+import { makeCreateRedo } from '@open-mercato/shared/lib/commands/redo'
 import { ensureOrganizationScope, ensureTenantScope, extractUndoPayload } from './shared'
 import { E } from '#generated/entities.ids.generated'
 
@@ -170,6 +171,26 @@ const createResourceTypeCommand: CommandHandler<ResourcesResourceTypeCreateInput
       })
     }
   },
+  redo: makeCreateRedo<ResourcesResourceType, ResourceTypeSnapshot, ResourcesResourceTypeCreateInput, { resourceTypeId: string }>({
+    entityClass: ResourcesResourceType,
+    buildResult: (entity) => ({ resourceTypeId: entity.id }),
+    events: resourcesResourceTypeCrudEvents,
+    indexer: resourceTypeCrudIndexer,
+    afterRestore: async ({ ctx, entity, logEntry }) => {
+      const payload = extractUndoPayload<ResourceTypeUndoPayload>(logEntry)
+      if (!payload?.customAfter) return
+      const dataEngine = (ctx.container.resolve('dataEngine') as DataEngine)
+      const reset = buildCustomFieldResetMap(payload.customAfter, undefined)
+      await setCustomFieldsIfAny({
+        dataEngine,
+        entityId: E.resources.resources_resource_type,
+        recordId: entity.id,
+        tenantId: entity.tenantId,
+        organizationId: entity.organizationId,
+        values: reset,
+      })
+    },
+  }),
 }
 
 const updateResourceTypeCommand: CommandHandler<ResourcesResourceTypeUpdateInput, { resourceTypeId: string }> = {

package/src/modules/resources/commands/resources.ts

@@ -6,6 +6,7 @@ import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { buildChanges, emitCrudSideEffects, emitCrudUndoSideEffects, parseWithCustomFields, setCustomFieldsIfAny } from '@open-mercato/shared/lib/commands/helpers'
 import { withAtomicFlush } from '@open-mercato/shared/lib/commands/flush'
 import { buildCustomFieldResetMap, diffCustomFieldChanges, loadCustomFieldSnapshot, type CustomFieldSnapshot } from '@open-mercato/shared/lib/commands/customFieldSnapshots'
+import { resolveRedoSnapshot } from '@open-mercato/shared/lib/commands/redo'
 import type { DataEngine } from '@open-mercato/shared/lib/data/engine'
 import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
 import type { CrudIndexerConfig } from '@open-mercato/shared/lib/crud/types'
@@ -329,6 +330,94 @@ const createResourceCommand: CommandHandler<ResourcesResourceCreateInput, { reso
       })
     }
   },
+  redo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload<ResourceUndoPayload>(logEntry)
+    const after = resolveRedoSnapshot<ResourceSnapshot>(logEntry)
+    if (!after) {
+      throw new CrudHttpError(400, { error: '[internal] redo snapshot unavailable for resource create' })
+    }
+    const fallbackCustomAfter = (after as ResourceSnapshot).customFields ?? null
+    const em = (ctx.container.resolve('em') as EntityManager).fork()
+    let record = await em.findOne(ResourcesResource, { id: after.id })
+    await withAtomicFlush(em, [
+      async () => {
+        if (!record) {
+          record = em.create(ResourcesResource, {
+            id: after.id,
+            tenantId: after.tenantId,
+            organizationId: after.organizationId,
+            name: after.name,
+            description: after.description ?? null,
+            resourceTypeId: after.resourceTypeId ?? null,
+            capacity: after.capacity ?? null,
+            capacityUnitValue: after.capacityUnitValue ?? null,
+            capacityUnitName: after.capacityUnitName ?? null,
+            capacityUnitColor: after.capacityUnitColor ?? null,
+            capacityUnitIcon: after.capacityUnitIcon ?? null,
+            appearanceIcon: after.appearanceIcon ?? null,
+            appearanceColor: after.appearanceColor ?? null,
+            isActive: after.isActive,
+            availabilityRuleSetId: after.availabilityRuleSetId ?? null,
+            deletedAt: null,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          })
+          em.persist(record)
+        } else {
+          record.name = after.name
+          record.description = after.description ?? null
+          record.resourceTypeId = after.resourceTypeId ?? null
+          record.capacity = after.capacity ?? null
+          record.capacityUnitValue = after.capacityUnitValue ?? null
+          record.capacityUnitName = after.capacityUnitName ?? null
+          record.capacityUnitColor = after.capacityUnitColor ?? null
+          record.capacityUnitIcon = after.capacityUnitIcon ?? null
+          record.appearanceIcon = after.appearanceIcon ?? null
+          record.appearanceColor = after.appearanceColor ?? null
+          record.isActive = after.isActive
+          record.availabilityRuleSetId = after.availabilityRuleSetId ?? null
+          record.deletedAt = null
+          record.updatedAt = new Date()
+        }
+        await em.flush()
+      },
+      () => syncResourcesResourceTags(em, {
+        resourceId: (record as ResourcesResource).id,
+        organizationId: (record as ResourcesResource).organizationId,
+        tenantId: (record as ResourcesResource).tenantId,
+        tagIds: after.tags,
+      }),
+    ], { transaction: true })
+    const resolvedRecord = record as ResourcesResource
+
+    const dataEngine = (ctx.container.resolve('dataEngine') as DataEngine)
+    const customAfter = payload?.customAfter ?? fallbackCustomAfter ?? undefined
+    if (customAfter) {
+      const reset = buildCustomFieldResetMap(customAfter, undefined)
+      await setCustomFieldsIfAny({
+        dataEngine,
+        entityId: E.resources.resources_resource,
+        recordId: resolvedRecord.id,
+        tenantId: resolvedRecord.tenantId,
+        organizationId: resolvedRecord.organizationId,
+        values: reset,
+      })
+    }
+
+    await emitCrudSideEffects({
+      dataEngine,
+      action: 'created',
+      entity: resolvedRecord,
+      identifiers: {
+        id: resolvedRecord.id,
+        organizationId: resolvedRecord.organizationId,
+        tenantId: resolvedRecord.tenantId,
+      },
+      events: resourcesResourceCrudEvents,
+      indexer: resourceCrudIndexer,
+    })
+    return { resourceId: resolvedRecord.id }
+  },
 }
 
 const updateResourceCommand: CommandHandler<ResourcesResourceUpdateInput, { resourceId: string }> = {