@open-mercato/core 0.4.2-canary-51881f6bf3 → 0.4.2-canary-5f415b8a44

package/generated/entities.ids.generated.ts

@@ -30,34 +30,34 @@ export const E = {
     "dashboard_user_widgets": "dashboards:dashboard_user_widgets"
   },
   "auth": {
-    "user": "auth:user",
+    "password_reset": "auth:password_reset",
     "role": "auth:role",
-    "user_sidebar_preference": "auth:user_sidebar_preference",
+    "role_acl": "auth:role_acl",
     "role_sidebar_preference": "auth:role_sidebar_preference",
-    "user_role": "auth:user_role",
     "session": "auth:session",
-    "password_reset": "auth:password_reset",
-    "role_acl": "auth:role_acl",
-    "user_acl": "auth:user_acl"
+    "user": "auth:user",
+    "user_acl": "auth:user_acl",
+    "user_role": "auth:user_role",
+    "user_sidebar_preference": "auth:user_sidebar_preference"
   },
   "directory": {
-    "tenant": "directory:tenant",
-    "organization": "directory:organization"
+    "organization": "directory:organization",
+    "tenant": "directory:tenant"
   },
   "customers": {
-    "customer_entity": "customers:customer_entity",
-    "customer_person_profile": "customers:customer_person_profile",
+    "customer_activity": "customers:customer_activity",
+    "customer_address": "customers:customer_address",
+    "customer_comment": "customers:customer_comment",
     "customer_company_profile": "customers:customer_company_profile",
     "customer_deal": "customers:customer_deal",
-    "customer_deal_person_link": "customers:customer_deal_person_link",
     "customer_deal_company_link": "customers:customer_deal_company_link",
-    "customer_activity": "customers:customer_activity",
-    "customer_comment": "customers:customer_comment",
-    "customer_address": "customers:customer_address",
+    "customer_deal_person_link": "customers:customer_deal_person_link",
+    "customer_dictionary_entry": "customers:customer_dictionary_entry",
+    "customer_entity": "customers:customer_entity",
+    "customer_person_profile": "customers:customer_person_profile",
     "customer_settings": "customers:customer_settings",
     "customer_tag": "customers:customer_tag",
     "customer_tag_assignment": "customers:customer_tag_assignment",
-    "customer_dictionary_entry": "customers:customer_dictionary_entry",
     "customer_todo_link": "customers:customer_todo_link"
   },
   "perspectives": {
@@ -65,10 +65,10 @@ export const E = {
     "role_perspective": "perspectives:role_perspective"
   },
   "entities": {
-    "custom_field_def": "entities:custom_field_def",
-    "custom_field_entity_config": "entities:custom_field_entity_config",
     "custom_entity": "entities:custom_entity",
     "custom_entity_storage": "entities:custom_entity_storage",
+    "custom_field_def": "entities:custom_field_def",
+    "custom_field_entity_config": "entities:custom_field_entity_config",
     "custom_field_value": "entities:custom_field_value",
     "encryption_map": "entities:encryption_map"
   },
@@ -77,60 +77,60 @@ export const E = {
     "upgrade_action_run": "configs:upgrade_action_run"
   },
   "query_index": {
-    "entity_index_row": "query_index:entity_index_row",
-    "entity_index_job": "query_index:entity_index_job",
     "entity_index_coverage": "query_index:entity_index_coverage",
+    "entity_index_job": "query_index:entity_index_job",
+    "entity_index_row": "query_index:entity_index_row",
     "indexer_error_log": "query_index:indexer_error_log",
     "indexer_status_log": "query_index:indexer_status_log",
     "search_token": "query_index:search_token"
   },
   "audit_logs": {
-    "action_log": "audit_logs:action_log",
-    "access_log": "audit_logs:access_log"
+    "access_log": "audit_logs:access_log",
+    "action_log": "audit_logs:action_log"
   },
   "attachments": {
-    "attachment_partition": "attachments:attachment_partition",
-    "attachment": "attachments:attachment"
+    "attachment": "attachments:attachment",
+    "attachment_partition": "attachments:attachment_partition"
   },
   "catalog": {
+    "catalog_offer": "catalog:catalog_offer",
     "catalog_option_schema_template": "catalog:catalog_option_schema_template",
+    "catalog_price_kind": "catalog:catalog_price_kind",
     "catalog_product": "catalog:catalog_product",
     "catalog_product_category": "catalog:catalog_product_category",
     "catalog_product_category_assignment": "catalog:catalog_product_category_assignment",
+    "catalog_product_price": "catalog:catalog_product_price",
     "catalog_product_tag": "catalog:catalog_product_tag",
     "catalog_product_tag_assignment": "catalog:catalog_product_tag_assignment",
-    "catalog_offer": "catalog:catalog_offer",
     "catalog_product_variant": "catalog:catalog_product_variant",
-    "catalog_product_variant_relation": "catalog:catalog_product_variant_relation",
-    "catalog_price_kind": "catalog:catalog_price_kind",
-    "catalog_product_price": "catalog:catalog_product_price"
+    "catalog_product_variant_relation": "catalog:catalog_product_variant_relation"
   },
   "sales": {
     "sales_channel": "sales:sales_channel",
-    "sales_shipping_method": "sales:sales_shipping_method",
+    "sales_credit_memo": "sales:sales_credit_memo",
+    "sales_credit_memo_line": "sales:sales_credit_memo_line",
     "sales_delivery_window": "sales:sales_delivery_window",
-    "sales_payment_method": "sales:sales_payment_method",
-    "sales_tax_rate": "sales:sales_tax_rate",
+    "sales_document_address": "sales:sales_document_address",
+    "sales_document_sequence": "sales:sales_document_sequence",
+    "sales_document_tag": "sales:sales_document_tag",
+    "sales_document_tag_assignment": "sales:sales_document_tag_assignment",
+    "sales_invoice": "sales:sales_invoice",
+    "sales_invoice_line": "sales:sales_invoice_line",
+    "sales_note": "sales:sales_note",
     "sales_order": "sales:sales_order",
-    "sales_order_line": "sales:sales_order_line",
     "sales_order_adjustment": "sales:sales_order_adjustment",
-    "sales_settings": "sales:sales_settings",
-    "sales_document_sequence": "sales:sales_document_sequence",
+    "sales_order_line": "sales:sales_order_line",
+    "sales_payment": "sales:sales_payment",
+    "sales_payment_allocation": "sales:sales_payment_allocation",
+    "sales_payment_method": "sales:sales_payment_method",
     "sales_quote": "sales:sales_quote",
-    "sales_quote_line": "sales:sales_quote_line",
     "sales_quote_adjustment": "sales:sales_quote_adjustment",
+    "sales_quote_line": "sales:sales_quote_line",
+    "sales_settings": "sales:sales_settings",
     "sales_shipment": "sales:sales_shipment",
     "sales_shipment_item": "sales:sales_shipment_item",
-    "sales_invoice": "sales:sales_invoice",
-    "sales_invoice_line": "sales:sales_invoice_line",
-    "sales_credit_memo": "sales:sales_credit_memo",
-    "sales_credit_memo_line": "sales:sales_credit_memo_line",
-    "sales_payment": "sales:sales_payment",
-    "sales_payment_allocation": "sales:sales_payment_allocation",
-    "sales_note": "sales:sales_note",
-    "sales_document_address": "sales:sales_document_address",
-    "sales_document_tag": "sales:sales_document_tag",
-    "sales_document_tag_assignment": "sales:sales_document_tag_assignment"
+    "sales_shipping_method": "sales:sales_shipping_method",
+    "sales_tax_rate": "sales:sales_tax_rate"
   },
   "api_keys": {
     "api_key": "api_keys:api_key"
@@ -150,38 +150,39 @@ export const E = {
     "feature_toggle_override": "feature_toggles:feature_toggle_override"
   },
   "workflows": {
-    "workflow_definition": "workflows:workflow_definition",
-    "workflow_instance": "workflows:workflow_instance",
     "step_instance": "workflows:step_instance",
     "user_task": "workflows:user_task",
-    "workflow_event": "workflows:workflow_event"
+    "workflow_definition": "workflows:workflow_definition",
+    "workflow_event": "workflows:workflow_event",
+    "workflow_event_trigger": "workflows:workflow_event_trigger",
+    "workflow_instance": "workflows:workflow_instance"
   },
   "currencies": {
     "currency": "currencies:currency",
-    "exchange_rate": "currencies:exchange_rate",
-    "currency_fetch_config": "currencies:currency_fetch_config"
+    "currency_fetch_config": "currencies:currency_fetch_config",
+    "exchange_rate": "currencies:exchange_rate"
   },
   "planner": {
-    "planner_availability_rule_set": "planner:planner_availability_rule_set",
-    "planner_availability_rule": "planner:planner_availability_rule"
+    "planner_availability_rule": "planner:planner_availability_rule",
+    "planner_availability_rule_set": "planner:planner_availability_rule_set"
   },
   "resources": {
-    "resources_resource_type": "resources:resources_resource_type",
     "resources_resource": "resources:resources_resource",
-    "resources_resource_comment": "resources:resources_resource_comment",
     "resources_resource_activity": "resources:resources_resource_activity",
+    "resources_resource_comment": "resources:resources_resource_comment",
     "resources_resource_tag": "resources:resources_resource_tag",
-    "resources_resource_tag_assignment": "resources:resources_resource_tag_assignment"
+    "resources_resource_tag_assignment": "resources:resources_resource_tag_assignment",
+    "resources_resource_type": "resources:resources_resource_type"
   },
   "staff": {
+    "staff_leave_request": "staff:staff_leave_request",
     "staff_team": "staff:staff_team",
-    "staff_team_role": "staff:staff_team_role",
     "staff_team_member": "staff:staff_team_member",
-    "staff_leave_request": "staff:staff_leave_request",
-    "staff_team_member_comment": "staff:staff_team_member_comment",
     "staff_team_member_activity": "staff:staff_team_member_activity",
+    "staff_team_member_address": "staff:staff_team_member_address",
+    "staff_team_member_comment": "staff:staff_team_member_comment",
     "staff_team_member_job_history": "staff:staff_team_member_job_history",
-    "staff_team_member_address": "staff:staff_team_member_address"
+    "staff_team_role": "staff:staff_team_role"
   }
 } as const
 export type KnownModuleId = keyof typeof M

package/generated/entity-fields-registry.ts

@@ -116,6 +116,7 @@ import * as user_sidebar_preference from './entities/user_sidebar_preference/ind
 import * as user_task from './entities/user_task/index'
 import * as workflow_definition from './entities/workflow_definition/index'
 import * as workflow_event from './entities/workflow_event/index'
+import * as workflow_event_trigger from './entities/workflow_event_trigger/index'
 import * as workflow_instance from './entities/workflow_instance/index'
 
 export const entityFieldsRegistry: Record<string, Record<string, string>> = {
@@ -235,6 +236,7 @@ export const entityFieldsRegistry: Record<string, Record<string, string>> = {
   user_task,
   workflow_definition,
   workflow_event,
+  workflow_event_trigger,
   workflow_instance
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/core",
-  "version": "0.4.2-canary-51881f6bf3",
+  "version": "0.4.2-canary-5f415b8a44",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -207,12 +207,10 @@
     }
   },
   "dependencies": {
-    "@open-mercato/shared": "0.4.2-canary-51881f6bf3",
-    "@types/semver": "^7.5.8",
+    "@open-mercato/shared": "0.4.2-canary-5f415b8a44",
     "@xyflow/react": "^12.6.0",
     "date-fns": "^4.1.0",
-    "date-fns-tz": "^3.2.0",
-    "semver": "^7.6.3"
+    "date-fns-tz": "^3.2.0"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",

package/src/modules/auth/events.ts

@@ -0,0 +1,39 @@
+import { createModuleEvents } from '@open-mercato/shared/modules/events'
+
+/**
+ * Auth Module Events
+ *
+ * Declares all events that can be emitted by the auth module.
+ */
+const events = [
+  // Users
+  { id: 'auth.users.created', label: 'User Created', entity: 'users', category: 'crud' },
+  { id: 'auth.users.updated', label: 'User Updated', entity: 'users', category: 'crud' },
+  { id: 'auth.users.deleted', label: 'User Deleted', entity: 'users', category: 'crud' },
+
+  // Roles
+  { id: 'auth.roles.created', label: 'Role Created', entity: 'roles', category: 'crud' },
+  { id: 'auth.roles.updated', label: 'Role Updated', entity: 'roles', category: 'crud' },
+  { id: 'auth.roles.deleted', label: 'Role Deleted', entity: 'roles', category: 'crud' },
+
+  // Authentication events
+  { id: 'auth.login.success', label: 'Login Successful', category: 'lifecycle' },
+  { id: 'auth.login.failed', label: 'Login Failed', category: 'lifecycle' },
+  { id: 'auth.logout', label: 'User Logged Out', category: 'lifecycle' },
+  { id: 'auth.password.changed', label: 'Password Changed', category: 'lifecycle' },
+  { id: 'auth.password.reset.requested', label: 'Password Reset Requested', category: 'lifecycle' },
+  { id: 'auth.password.reset.completed', label: 'Password Reset Completed', category: 'lifecycle' },
+] as const
+
+export const eventsConfig = createModuleEvents({
+  moduleId: 'auth',
+  events,
+})
+
+/** Type-safe event emitter for auth module */
+export const emitAuthEvent = eventsConfig.emit
+
+/** Event IDs that can be emitted by the auth module */
+export type AuthEventId = typeof events[number]['id']
+
+export default eventsConfig

package/src/modules/business_rules/api/execute/[ruleId]/route.ts

@@ -0,0 +1,163 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import * as ruleEngine from '../../../lib/rule-engine'
+
+const executeByIdRequestSchema = z.object({
+  data: z.any(),
+  dryRun: z.boolean().optional().default(false),
+  entityType: z.string().optional(),
+  entityId: z.string().optional(),
+  eventType: z.string().optional(),
+})
+
+const executeByIdResponseSchema = z.object({
+  success: z.boolean(),
+  ruleId: z.string(),
+  ruleName: z.string(),
+  conditionResult: z.boolean(),
+  actionsExecuted: z.object({
+    success: z.boolean(),
+    results: z.array(z.object({
+      type: z.string(),
+      success: z.boolean(),
+      error: z.string().optional(),
+    })),
+  }).nullable(),
+  executionTime: z.number(),
+  error: z.string().optional(),
+  logId: z.string().optional(),
+})
+
+const errorResponseSchema = z.object({
+  error: z.string(),
+})
+
+const routeMetadata = {
+  POST: { requireAuth: true, requireFeatures: ['business_rules.execute'] },
+}
+
+export const metadata = routeMetadata
+
+interface RouteContext {
+  params: Promise<{ ruleId: string }>
+}
+
+export async function POST(req: Request, context: RouteContext) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const params = await context.params
+  const ruleId = params.ruleId
+
+  if (!ruleId || !z.uuid().safeParse(ruleId).success) {
+    return NextResponse.json({ error: 'Invalid rule ID' }, { status: 400 })
+  }
+
+  const container = await createRequestContainer()
+  const em = container.resolve('em') as EntityManager
+
+  let body: any
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 })
+  }
+
+  const parsed = executeByIdRequestSchema.safeParse(body)
+  if (!parsed.success) {
+    const errors = parsed.error.issues.map(e => `${e.path.join('.')}: ${e.message}`)
+    return NextResponse.json({ error: `Validation failed: ${errors.join(', ')}` }, { status: 400 })
+  }
+
+  const { data, dryRun, entityType, entityId, eventType } = parsed.data
+
+  const execContext: ruleEngine.DirectRuleExecutionContext = {
+    ruleId,
+    data,
+    user: {
+      id: auth.sub,
+      email: auth.email,
+      role: (auth.role as string) ?? undefined,
+    },
+    tenantId: auth.tenantId ?? '',
+    organizationId: auth.orgId ?? '',
+    executedBy: auth.sub ?? auth.email ?? undefined,
+    dryRun,
+    entityType,
+    entityId,
+    eventType,
+  }
+
+  try {
+    const result = await ruleEngine.executeRuleById(em, execContext)
+
+    const response = {
+      success: result.success,
+      ruleId: result.ruleId,
+      ruleName: result.ruleName,
+      conditionResult: result.conditionResult,
+      actionsExecuted: result.actionsExecuted ? {
+        success: result.actionsExecuted.success,
+        results: result.actionsExecuted.results.map(ar => ({
+          type: ar.action.type,
+          success: ar.success,
+          error: ar.error,
+        })),
+      } : null,
+      executionTime: result.executionTime,
+      error: result.error,
+      logId: result.logId,
+    }
+
+    // Return appropriate status based on result
+    const status = result.success ? 200 : (result.error === 'Rule not found' ? 404 : 200)
+    return NextResponse.json(response, { status })
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    return NextResponse.json(
+      { error: `Rule execution failed: ${errorMessage}` },
+      { status: 500 }
+    )
+  }
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Business Rules',
+  summary: 'Execute a specific business rule by ID',
+  methods: {
+    POST: {
+      summary: 'Execute a specific rule by its database UUID',
+      description: 'Directly executes a specific business rule identified by its UUID, bypassing the normal entityType/eventType discovery mechanism. Useful for workflows and targeted rule execution.',
+      pathParams: z.object({
+        ruleId: z.string().uuid().describe('The database UUID of the business rule to execute'),
+      }),
+      requestBody: {
+        contentType: 'application/json',
+        schema: executeByIdRequestSchema,
+      },
+      responses: [
+        {
+          status: 200,
+          description: 'Rule executed successfully',
+          schema: executeByIdResponseSchema,
+        },
+        {
+          status: 404,
+          description: 'Rule not found',
+          schema: errorResponseSchema,
+        },
+      ],
+      errors: [
+        { status: 400, description: 'Invalid request payload or rule ID', schema: errorResponseSchema },
+        { status: 401, description: 'Unauthorized', schema: errorResponseSchema },
+        { status: 500, description: 'Execution error', schema: errorResponseSchema },
+      ],
+    },
+  },
+}

package/src/modules/business_rules/data/validators.ts

@@ -287,3 +287,43 @@ export const ruleDiscoveryOptionsSchema = z.object({
 })
 
 export type RuleDiscoveryOptionsInput = z.infer<typeof ruleDiscoveryOptionsSchema>
+
+// Direct Rule Execution Context Schema (for executing a specific rule by ID)
+export const directRuleExecutionContextSchema = z.object({
+  ruleId: z.uuid('ruleId must be a valid UUID'),
+  data: z.any(),
+  user: z.looseObject({
+    id: z.string().optional(),
+    email: z.string().optional(),
+    role: z.string().optional(),
+  }).optional(),
+  tenantId: z.uuid('tenantId must be a valid UUID'),
+  organizationId: z.uuid('organizationId must be a valid UUID'),
+  executedBy: z.string().optional(),
+  dryRun: z.boolean().optional(),
+  entityType: z.string().optional(),
+  entityId: z.string().optional(),
+  eventType: z.string().optional(),
+})
+
+export type DirectRuleExecutionContextInput = z.infer<typeof directRuleExecutionContextSchema>
+
+// Rule ID Execution Context Schema (for executing a specific rule by its string rule_id identifier)
+export const ruleIdExecutionContextSchema = z.object({
+  ruleId: z.string().min(1, 'ruleId must be a non-empty string').max(50),
+  data: z.any(),
+  user: z.looseObject({
+    id: z.string().optional(),
+    email: z.string().optional(),
+    role: z.string().optional(),
+  }).optional(),
+  tenantId: z.uuid('tenantId must be a valid UUID'),
+  organizationId: z.uuid('organizationId must be a valid UUID'),
+  executedBy: z.string().optional(),
+  dryRun: z.boolean().optional(),
+  entityType: z.string().optional(),
+  entityId: z.string().optional(),
+  eventType: z.string().optional(),
+})
+
+export type RuleIdExecutionContextInput = z.infer<typeof ruleIdExecutionContextSchema>

package/src/modules/business_rules/index.ts

@@ -8,3 +8,28 @@ export const metadata: ModuleInfo = {
   author: 'Patryk Lewczuk',
   license: 'Proprietary',
 }
+
+// Export rule engine types and functions for programmatic usage
+export {
+  executeRules,
+  executeRuleById,
+  executeRuleByRuleId,
+  executeSingleRule,
+  findApplicableRules,
+  logRuleExecution,
+  type RuleEngineContext,
+  type RuleEngineResult,
+  type RuleExecutionResult,
+  type RuleDiscoveryOptions,
+  type DirectRuleExecutionContext,
+  type DirectRuleExecutionResult,
+  type RuleIdExecutionContext,
+} from './lib/rule-engine'
+
+// Export validator schemas
+export {
+  directRuleExecutionContextSchema,
+  ruleIdExecutionContextSchema,
+  type DirectRuleExecutionContextInput,
+  type RuleIdExecutionContextInput,
+} from './data/validators'