@porulle/core 0.10.6 → 0.11.0

package/src/modules/catalog/schema.ts

@@ -5,9 +5,12 @@ import {
   index,
   integer,
   jsonb,
+  numeric,
+  pgEnum,
   pgTable,
   text,
   timestamp,
+  unique,
   uniqueIndex,
   uuid,
 } from "drizzle-orm/pg-core";
@@ -77,15 +80,35 @@ export const sellableCustomFields = pgTable(
       .notNull(),
     fieldName: text("field_name").notNull(),
     fieldType: text("field_type", {
-      enum: ["text", "number", "boolean", "date", "json", "relation"],
+      enum: ["text", "number", "boolean", "date", "json", "relation", "select"],
     }).notNull(),
+    source: text("source", {
+      enum: ["merchant", "import", "enrichment", "rule"],
+    }).notNull().default("merchant"),
+    status: text("status", {
+      enum: ["proposed", "approved", "rejected"],
+    }).notNull().default("approved"),
+    confidence: numeric("confidence", { precision: 4, scale: 3 }),
+    evidence: jsonb("evidence").$type<Record<string, unknown>>(),
+    locale: text("locale").notNull().default("en"),
+    approvedAt: timestamp("approved_at", { withTimezone: true }),
+    approvedBy: text("approved_by"),
     textValue: text("text_value"),
     numberValue: integer("number_value"),
     booleanValue: boolean("boolean_value"),
     dateValue: timestamp("date_value", { withTimezone: true }),
     jsonValue: jsonb("json_value"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
   },
   (table) => ({
+    liveUnique: uniqueIndex("sellable_custom_fields_live_unique")
+      .on(
+        table.entityId,
+        table.fieldName,
+        table.locale,
+      )
+      .where(sql`${table.status} = 'approved'`),
     entityFieldIdx: index("idx_custom_fields_entity_field").on(
       table.entityId,
       table.fieldName,
@@ -101,6 +124,41 @@ export const sellableCustomFields = pgTable(
   }),
 );
 
+export const entityFieldDefinitions = pgTable(
+  "entity_field_definitions",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "cascade" }),
+    entityType: text("entity_type").notNull(),
+    name: text("name").notNull(),
+    type: text("type", {
+      enum: ["text", "number", "boolean", "date", "json", "relation", "select"],
+    }).notNull(),
+    unit: text("unit"),
+    options: jsonb("options").$type<string[]>(),
+    target: text("target"),
+    filterable: boolean("filterable").notNull().default(false),
+    localized: boolean("localized").notNull().default(false),
+    status: text("status", { enum: ["active", "archived"] })
+      .notNull()
+      .default("active"),
+    sortOrder: integer("sort_order").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    organizationIdx: index("idx_entity_field_definitions_organization").on(table.organizationId),
+    entityTypeIdx: index("idx_entity_field_definitions_entity_type").on(table.organizationId, table.entityType),
+    organizationEntityTypeNameUnique: uniqueIndex("entity_field_definitions_org_type_name_unique").on(
+      table.organizationId,
+      table.entityType,
+      table.name,
+    ),
+  }),
+);
+
 export const categories = pgTable(
   "categories",
   {
@@ -161,6 +219,85 @@ export const entityBrands = pgTable("entity_brands", {
   entityBrandUnique: uniqueIndex("entity_brands_entity_brand_unique").on(table.entityId, table.brandId),
 }));
 
+export const tags = pgTable(
+  "tags",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    slug: text("slug").notNull(),
+    displayName: text("display_name").notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_tags_org").on(table.organizationId),
+    orgSlugUnique: uniqueIndex("tags_org_slug_unique").on(table.organizationId, table.slug),
+  }),
+);
+
+export const entityTags = pgTable("entity_tags", {
+  entityId: uuid("entity_id")
+    .references(() => sellableEntities.id, { onDelete: "cascade" })
+    .notNull(),
+  tagId: uuid("tag_id")
+    .references(() => tags.id, { onDelete: "cascade" })
+    .notNull(),
+}, (table) => ({
+  entityTagUnique: uniqueIndex("entity_tags_entity_tag_unique").on(table.entityId, table.tagId),
+}));
+
+export const sellableEntityRevisionReason = pgEnum("sellable_entity_revision_reason", [
+  "create",
+  "update",
+  "import",
+  "enrichment",
+  "push",
+  "restore",
+]);
+
+export type SellableEntityRevisionReason = (typeof sellableEntityRevisionReason.enumValues)[number];
+
+export type SellableEntityRevisionSnapshot = {
+  entity: Record<string, unknown>;
+  attributes: Array<Record<string, unknown>>;
+  customFields: Array<Record<string, unknown>>;
+  media: Array<Record<string, unknown>>;
+  categories: Array<Record<string, unknown>>;
+  brands: Array<Record<string, unknown>>;
+  // Optional: snapshots written before tags existed do not carry the key.
+  tags?: Array<Record<string, unknown>>;
+};
+
+export const sellableEntityRevisions = pgTable(
+  "sellable_entity_revisions",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+      .references(() => organization.id, { onDelete: "cascade" })
+      .notNull(),
+    entityId: uuid("entity_id")
+      .references(() => sellableEntities.id, { onDelete: "cascade" })
+      .notNull(),
+    revision: integer("revision").notNull(),
+    snapshot: jsonb("snapshot").$type<SellableEntityRevisionSnapshot>().notNull(),
+    reason: sellableEntityRevisionReason("reason").notNull(),
+    pinned: boolean("pinned").notNull().default(false),
+    actorId: text("actor_id"),
+    actorType: text("actor_type"),
+    requestId: text("request_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    entityRevisionUnique: uniqueIndex("sellable_entity_revisions_entity_revision_unique").on(
+      table.entityId,
+      table.revision,
+    ),
+    entityCreatedIdx: index("idx_sellable_entity_revisions_entity_created").on(
+      table.entityId,
+      table.createdAt,
+    ),
+    organizationIdx: index("idx_sellable_entity_revisions_organization").on(table.organizationId),
+  }),
+);
+
 export const optionTypes = pgTable("option_types", {
   id: uuid("id").defaultRandom().primaryKey(),
   entityId: uuid("entity_id")
@@ -223,3 +360,34 @@ export const variantOptionValues = pgTable("variant_option_values", {
 }, (table) => ({
   variantOptionValueUnique: uniqueIndex("variant_option_values_variant_option_unique").on(table.variantId, table.optionValueId),
 }));
+
+export const catalogFieldOwner = pgEnum("catalog_field_owner", ["platform", "store", "shared"]);
+
+export const catalogFieldOwnership = pgTable(
+  "catalog_field_ownership",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id")
+      .notNull()
+      .references(() => organization.id, { onDelete: "cascade" }),
+    entityId: uuid("entity_id")
+      .notNull()
+      .references(() => sellableEntities.id, { onDelete: "cascade" }),
+    variantId: uuid("variant_id").references(() => variants.id, { onDelete: "cascade" }),
+    storeId: text("store_id"),
+    fieldPath: text("field_path").notNull(),
+    owner: catalogFieldOwner("owner").notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    ownershipUnique: unique("catalog_field_ownership_key")
+      .on(table.organizationId, table.entityId, table.variantId, table.storeId, table.fieldPath)
+      .nullsNotDistinct(),
+    entityStoreFieldIdx: index("idx_catalog_field_ownership_entity_store_field").on(
+      table.entityId,
+      table.storeId,
+      table.variantId,
+      table.fieldPath,
+    ),
+  }),
+);

package/src/modules/catalog/schemas.ts

@@ -28,6 +28,7 @@ export const UpdateEntityBodySchema = z.object({
   taxClass: z.string().nullable().optional(),
   metadata: z.record(z.string(), z.unknown()).optional(),
   isVisible: z.boolean().optional(),
+  customFields: z.record(z.string(), z.unknown().nullable()).optional(),
 }).openapi("UpdateEntityBody");
 
 export const SetAttributesBodySchema = z.record(z.string(), z.unknown()).openapi("SetAttributesBody");
@@ -69,6 +70,7 @@ export const CreateOptionValueBodySchema = z.object({
 
 export const CreateVariantBodySchema = z.object({
   sku: z.string().optional().openapi({ example: "SKU-001" }),
+  barcode: z.string().optional().openapi({ example: "0123456789012" }),
   options: z.record(z.string(), z.string()).openapi({ example: { Color: "Red" } }),
   price: z.number().optional().openapi({ example: 34.99 }),
   taxClass: z.string().optional().openapi({ example: "zero", description: "Overrides the entity's tax class (issue #57)." }),