@porulle/core 0.10.6 → 0.11.0

package/src/modules/catalog/entity-service.ts

@@ -36,6 +36,7 @@ import type {
   CreateOptionTypeInput,
   CreateOptionValueInput,
   CreateVariantInput,
+  EntityFieldDefinitionResolver,
 } from "./service.js";
 import type {
   SellableEntity,
@@ -69,6 +70,7 @@ function getCustomFieldValue(field: SellableCustomField): unknown {
   switch (field.fieldType) {
     case "text":
     case "relation":
+    case "select":
       return field.textValue;
     case "number":
       return field.numberValue;
@@ -83,8 +85,14 @@ function getCustomFieldValue(field: SellableCustomField): unknown {
   }
 }
 
+type CustomFieldData = Omit<SellableCustomFieldInsert, "entityId" | "fieldName" | "locale">;
+type ValidatedCustomField = { fieldName: string; locale: string; data: CustomFieldData | null };
+
 export class EntityService {
-  constructor(private readonly deps: CatalogServiceDeps) {}
+  constructor(
+    private readonly deps: CatalogServiceDeps,
+    private readonly resolveEntityFieldDefinitions: EntityFieldDefinitionResolver,
+  ) {}
 
   private get repo() {
     return this.deps.repository;
@@ -102,22 +110,38 @@ export class EntityService {
     if (entity.sourceStoreId != null) assertPermission(actor, "catalog:sync");
   }
 
-  private async validateAndCreateCustomFields(entityId: string, entityType: string, customFields: Record<string, unknown> | undefined, ctx?: TxContext): Promise<Result<void>> {
-    if (!customFields) return Ok(undefined);
+  private async validateCustomFields(entityType: string, customFields: Record<string, unknown> | undefined, actor: Actor | null, ctx?: TxContext): Promise<Result<ValidatedCustomField[]>> {
+    if (!customFields) return Ok([]);
     const entityConfig = this.deps.config.entities?.[entityType];
-    if (!entityConfig) return Ok(undefined);
-    const definitionMap = new Map(entityConfig.fields.map((f) => [f.name, f]));
+    const definitions = await this.resolveEntityFieldDefinitions(entityType, actor ?? ctx?.actor ?? null, ctx);
+    if (!entityConfig && definitions.length === 0) return Ok([]);
+    const definitionMap = new Map(definitions.map((f) => [f.name, f]));
+    const validated: ValidatedCustomField[] = [];
     for (const [name, value] of Object.entries(customFields)) {
       const def = definitionMap.get(name);
       if (!def) return Err(new CommerceValidationError(`Unknown custom field: ${name}`));
+      if (value === null) {
+        validated.push({ fieldName: name, locale: "en", data: null });
+        continue;
+      }
       const type = def.type;
+      let normalized = value;
       let valid = false;
       switch (type) {
         case "text":
         case "relation":
-        case "select":
           valid = typeof value === "string";
           break;
+        case "select": {
+          if (typeof value !== "string") break;
+          const trimmed = value.trim();
+          if (def.options && !def.options.includes(trimmed)) {
+            return Err(new CommerceValidationError(`Value "${trimmed}" is not permitted for field ${name}. Allowed: ${def.options.join(", ")}`));
+          }
+          normalized = trimmed;
+          valid = true;
+          break;
+        }
         case "number":
           valid = typeof value === "number";
           break;
@@ -134,29 +158,50 @@ export class EntityService {
           valid = false;
       }
       if (!valid) return Err(new CommerceValidationError(`Custom field ${name} expected type ${type}.`));
-      const fieldType = (type === "select" ? "text" : type) as SellableCustomField["fieldType"];
-      const insertData: SellableCustomFieldInsert = { entityId, fieldName: name, fieldType };
+      const fieldType = type as SellableCustomField["fieldType"];
+      const insertData: CustomFieldData = {
+        fieldType,
+        source: "merchant",
+        status: "approved",
+        confidence: null,
+        evidence: null,
+        approvedAt: null,
+        approvedBy: null,
+      };
       switch (fieldType) {
         case "text":
         case "relation":
-          insertData.textValue = value as string;
+        case "select":
+          insertData.textValue = normalized as string;
           break;
         case "number":
-          insertData.numberValue = value as number;
+          insertData.numberValue = normalized as number;
           break;
         case "boolean":
-          insertData.booleanValue = value as boolean;
+          insertData.booleanValue = normalized as boolean;
           break;
         case "date":
-          insertData.dateValue = value instanceof Date ? value : new Date(value as string);
+          insertData.dateValue = normalized instanceof Date ? normalized : new Date(normalized as string);
           break;
         case "json":
-          insertData.jsonValue = value;
+          insertData.jsonValue = normalized;
           break;
       }
-      await this.repo.createCustomField(insertData, ctx);
+      validated.push({ fieldName: name, locale: "en", data: insertData });
+    }
+    return Ok(validated);
+  }
+
+  private async writeCustomFields(entityId: string, customFields: ValidatedCustomField[], ctx?: TxContext, upsert = false): Promise<void> {
+    for (const customField of customFields) {
+      if (customField.data === null) {
+        await this.repo.deleteCustomField(entityId, customField.fieldName, customField.locale, ctx);
+      } else if (upsert) {
+        await this.repo.upsertCustomField(entityId, customField.fieldName, customField.locale, customField.data, ctx);
+      } else {
+        await this.repo.createCustomField({ ...customField.data, entityId, fieldName: customField.fieldName, locale: customField.locale }, ctx);
+      }
     }
-    return Ok(undefined);
   }
 
   private async hydrateEntity(entity: SellableEntity, options?: GetOptions, ctx?: TxContext): Promise<CatalogEntityHydrated> {
@@ -185,14 +230,16 @@ export class EntityService {
     }
     if (options?.includeCategories) hydrated.categories = await this.repo.findEntityCategories(entity.id, ctx);
     if (options?.includeBrands) hydrated.brands = await this.repo.findEntityBrands(entity.id, ctx);
+    if (options?.includeCustomFields) hydrated.customFields = await this.repo.findCustomFieldsByEntityId(entity.id, ctx);
     if (options?.includeMedia) {
       const mediaService = this.deps.services.media as {
         listEntityMedia?: (
           entityId: string,
           opts?: { orgId?: string },
+          ctx?: TxContext,
         ) => Promise<{ ok: boolean; value?: CatalogEntityHydrated["media"] }>;
       } | undefined;
-      const mediaResult = await mediaService?.listEntityMedia?.(entity.id, { orgId: entity.organizationId });
+      const mediaResult = await mediaService?.listEntityMedia?.(entity.id, { orgId: entity.organizationId }, ctx);
       hydrated.media = mediaResult?.ok && mediaResult.value ? mediaResult.value : [];
     }
     if (options?.includePricing) {
@@ -217,12 +264,15 @@ export class EntityService {
     const context: HookContext = createHookContext({ actor, tx: ctx?.tx ?? null, logger: createLogger("catalog.create"), services: this.deps.services, context: { moduleName: "catalog" }, ...hookDatabaseArg(this.deps.database) });
     const processedInput = await runBeforeHooks(beforeHooks, input, "create", context);
     if (processedInput.sourceStoreId != null) assertPermission(actor, "catalog:sync");
-    const entity = await this.repo.createEntity({ organizationId: orgId, type: processedInput.type, slug: processedInput.slug, status: "draft", isVisible: false, ...(processedInput.sourceStoreId !== undefined ? { sourceStoreId: processedInput.sourceStoreId } : {}), ...(processedInput.taxClass !== undefined ? { taxClass: processedInput.taxClass } : {}), metadata: processedInput.metadata ?? {} }, ctx);
+    const customFieldsResult = await this.validateCustomFields(processedInput.type, processedInput.customFields, actor, ctx);
+    if (!customFieldsResult.ok) return customFieldsResult;
+    const statuses = ["draft", "active", "archived", "discontinued"] as const;
+    const status = statuses.find((value) => value === processedInput.status) ?? "draft";
+    const entity = await this.repo.createEntity({ organizationId: orgId, type: processedInput.type, slug: processedInput.slug, status, isVisible: status === "active", ...(processedInput.sourceStoreId !== undefined ? { sourceStoreId: processedInput.sourceStoreId } : {}), ...(processedInput.taxClass !== undefined ? { taxClass: processedInput.taxClass } : {}), metadata: processedInput.metadata ?? {} }, ctx);
     if (processedInput.attributes) {
       await this.repo.createAttribute({ entityId: entity.id, locale: processedInput.attributes.locale ?? "en", title: processedInput.attributes.title, subtitle: processedInput.attributes.subtitle, description: processedInput.attributes.description, richDescription: processedInput.attributes.richDescription, seoTitle: processedInput.attributes.seoTitle, seoDescription: processedInput.attributes.seoDescription }, ctx);
     }
-    const customFieldsResult = await this.validateAndCreateCustomFields(entity.id, entity.type, processedInput.customFields, ctx);
-    if (!customFieldsResult.ok) return customFieldsResult;
+    await this.writeCustomFields(entity.id, customFieldsResult.value, ctx);
     const hookReport = await runAfterHooks(afterHooks, null, entity, "create", context);
     const hydrated = await this.hydrateEntity(entity, undefined, ctx);
     return Ok(hydrated, hookReport.hasErrors ? { hookErrors: hookReport.errors } : undefined);
@@ -238,8 +288,11 @@ export class EntityService {
     const afterHooks = this.deps.hooks.resolve("catalog.afterUpdate") as CatalogUpdateAfterHook[];
     const context: HookContext = createHookContext({ actor, tx: ctx?.tx ?? null, logger: createLogger("catalog.update"), services: this.deps.services, context: { moduleName: "catalog" }, ...hookDatabaseArg(this.deps.database) });
     const processed = await runBeforeHooks(beforeHooks, input, "update", context);
+    const customFieldsResult = await this.validateCustomFields(existing.type, processed.customFields, actor, ctx);
+    if (!customFieldsResult.ok) return customFieldsResult;
     const updated = await this.repo.updateEntity(id, { ...(processed.slug !== undefined ? { slug: processed.slug } : {}), ...(processed.status !== undefined ? { status: processed.status as SellableEntity["status"] } : {}), ...(processed.taxClass !== undefined ? { taxClass: processed.taxClass } : {}), ...(processed.metadata !== undefined ? { metadata: processed.metadata } : {}), ...(processed.isVisible !== undefined ? { isVisible: processed.isVisible } : {}) }, ctx);
     if (!updated) return Err(new CommerceNotFoundError("Entity not found."));
+    await this.writeCustomFields(existing.id, customFieldsResult.value, ctx, true);
     const hookReport = await runAfterHooks(afterHooks, existing, updated, "update", context);
     const hydrated = await this.hydrateEntity(updated, undefined, ctx);
     return Ok(hydrated, hookReport.hasErrors ? { hookErrors: hookReport.errors } : undefined);
@@ -467,7 +520,7 @@ export class EntityService {
       if (!ov) return Err(new CommerceValidationError(`Option value "${optVal}" does not exist for option type "${optName}".`));
       optionValueIds.push(ov.id);
     }
-    const variant = await this.repo.createVariant({ entityId: input.entityId, status: "active", sortOrder: 0, metadata: {}, ...(input.sku !== undefined ? { sku: input.sku } : {}), ...(input.taxClass !== undefined ? { taxClass: input.taxClass } : {}) }, ctx);
+    const variant = await this.repo.createVariant({ entityId: input.entityId, status: "active", sortOrder: 0, metadata: {}, ...(input.sku !== undefined ? { sku: input.sku } : {}), ...(input.barcode !== undefined ? { barcode: input.barcode } : {}), ...(input.taxClass !== undefined ? { taxClass: input.taxClass } : {}) }, ctx);
     await this.repo.createVariantOptionValues(optionValueIds.map((optionValueId) => ({ variantId: variant.id, optionValueId })), ctx);
     return Ok(variant);
   }

package/src/modules/catalog/module.ts

@@ -6,15 +6,20 @@ import { CatalogRepository } from "./repository/index.js";
 import {
   brands,
   categories,
+  tags,
+  entityTags,
   entityBrands,
   entityCategories,
   optionTypes,
   optionValues,
   sellableAttributes,
   sellableCustomFields,
+  entityFieldDefinitions,
+  sellableEntityRevisions,
   sellableEntities,
   variantOptionValues,
   variants,
+  catalogFieldOwnership,
 } from "./schema.js";
 import { CatalogServiceImpl } from "./service.js";
 
@@ -27,14 +32,19 @@ export const catalogModule = defineModule<
     sellableEntities: typeof sellableEntities;
     sellableAttributes: typeof sellableAttributes;
     sellableCustomFields: typeof sellableCustomFields;
+    entityFieldDefinitions: typeof entityFieldDefinitions;
+    sellableEntityRevisions: typeof sellableEntityRevisions;
     categories: typeof categories;
     entityCategories: typeof entityCategories;
     brands: typeof brands;
     entityBrands: typeof entityBrands;
+    tags: typeof tags;
+    entityTags: typeof entityTags;
     optionTypes: typeof optionTypes;
     optionValues: typeof optionValues;
     variants: typeof variants;
     variantOptionValues: typeof variantOptionValues;
+    catalogFieldOwnership: typeof catalogFieldOwnership;
   },
   CatalogServiceImpl,
   CatalogModuleDeps
@@ -45,14 +55,19 @@ export const catalogModule = defineModule<
     sellableEntities,
     sellableAttributes,
     sellableCustomFields,
+    entityFieldDefinitions,
+    sellableEntityRevisions,
     categories,
     entityCategories,
     brands,
     entityBrands,
+    tags,
+    entityTags,
     optionTypes,
     optionValues,
     variants,
     variantOptionValues,
+    catalogFieldOwnership,
   }),
   service: (deps) =>
     new CatalogServiceImpl({

package/src/modules/catalog/ownership.ts

@@ -0,0 +1,17 @@
+import { CommerceValidationError } from "../../kernel/errors.js";
+
+export type FieldPath = string;
+export type FieldOwner = "platform" | "store" | "shared";
+
+const fieldPathPattern = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
+
+export function isValidFieldPath(value: string): value is FieldPath {
+  return fieldPathPattern.test(value);
+}
+
+export function validateFieldPath(value: string): FieldPath {
+  if (!isValidFieldPath(value)) {
+    throw new CommerceValidationError("Field path must contain dot-separated alphanumeric, underscore, or hyphen segments.");
+  }
+  return value;
+}