@porulle/core 0.1.0

package/src/modules/catalog/schema.ts

@@ -0,0 +1,203 @@
+import type { AnyPgColumn } from "drizzle-orm/pg-core";
+import {
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+
+export const sellableEntities = pgTable(
+  "sellable_entities",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    type: text("type").notNull(),
+    slug: text("slug").notNull(),
+    status: text("status", {
+      enum: ["draft", "active", "archived", "discontinued"],
+    })
+      .notNull()
+      .default("draft"),
+    isVisible: boolean("is_visible").notNull().default(false),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+    publishedAt: timestamp("published_at", { withTimezone: true }),
+  },
+  (table) => ({
+    typeIdx: index("idx_sellable_entities_type").on(table.type),
+    statusIdx: index("idx_sellable_entities_status").on(table.status),
+    slugIdx: index("idx_sellable_entities_slug").on(table.slug),
+    orgIdx: index("idx_sellable_entities_org").on(table.organizationId),
+    orgSlugUnique: uniqueIndex("sellable_entities_org_slug_unique").on(table.organizationId, table.slug),
+  }),
+);
+
+export const sellableAttributes = pgTable(
+  "sellable_attributes",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    entityId: uuid("entity_id")
+      .references(() => sellableEntities.id, { onDelete: "cascade" })
+      .notNull(),
+    locale: text("locale").notNull().default("en"),
+    title: text("title").notNull(),
+    subtitle: text("subtitle"),
+    description: text("description"),
+    richDescription: jsonb("rich_description"),
+    seoTitle: text("seo_title"),
+    seoDescription: text("seo_description"),
+  },
+  (table) => ({
+    entityLocaleIdx: index("idx_sellable_attrs_entity_locale").on(
+      table.entityId,
+      table.locale,
+    ),
+  }),
+);
+
+export const sellableCustomFields = pgTable(
+  "sellable_custom_fields",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    entityId: uuid("entity_id")
+      .references(() => sellableEntities.id, { onDelete: "cascade" })
+      .notNull(),
+    fieldName: text("field_name").notNull(),
+    fieldType: text("field_type", {
+      enum: ["text", "number", "boolean", "date", "json", "relation"],
+    }).notNull(),
+    textValue: text("text_value"),
+    numberValue: integer("number_value"),
+    booleanValue: boolean("boolean_value"),
+    dateValue: timestamp("date_value", { withTimezone: true }),
+    jsonValue: jsonb("json_value"),
+  },
+  (table) => ({
+    entityFieldIdx: index("idx_custom_fields_entity_field").on(
+      table.entityId,
+      table.fieldName,
+    ),
+    textValueIdx: index("idx_custom_fields_text").on(
+      table.fieldName,
+      table.textValue,
+    ),
+    numberValueIdx: index("idx_custom_fields_number").on(
+      table.fieldName,
+      table.numberValue,
+    ),
+  }),
+);
+
+export const categories = pgTable(
+  "categories",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    // Self-referential FK — Drizzle requires AnyPgColumn for circular references.
+    parentId: uuid("parent_id").references((): AnyPgColumn => categories.id, {
+      onDelete: "set null",
+    }),
+    slug: text("slug").notNull(),
+    sortOrder: integer("sort_order").notNull().default(0),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  },
+  (table) => ({
+    orgIdx: index("idx_categories_org").on(table.organizationId),
+    orgSlugUnique: uniqueIndex("categories_org_slug_unique").on(table.organizationId, table.slug),
+  }),
+);
+
+export const entityCategories = pgTable("entity_categories", {
+  entityId: uuid("entity_id")
+    .references(() => sellableEntities.id, { onDelete: "cascade" })
+    .notNull(),
+  categoryId: uuid("category_id")
+    .references(() => categories.id, { onDelete: "cascade" })
+    .notNull(),
+  sortOrder: integer("sort_order").notNull().default(0),
+}, (table) => ({
+  entityCategoryUnique: uniqueIndex("entity_categories_entity_category_unique").on(table.entityId, table.categoryId),
+}));
+
+export const brands = pgTable(
+  "brands",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
+    slug: text("slug").notNull(),
+    displayName: text("display_name").notNull(),
+    metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+  },
+  (table) => ({
+    orgIdx: index("idx_brands_org").on(table.organizationId),
+    orgSlugUnique: uniqueIndex("brands_org_slug_unique").on(table.organizationId, table.slug),
+  }),
+);
+
+export const entityBrands = pgTable("entity_brands", {
+  entityId: uuid("entity_id")
+    .references(() => sellableEntities.id, { onDelete: "cascade" })
+    .notNull(),
+  brandId: uuid("brand_id")
+    .references(() => brands.id, { onDelete: "cascade" })
+    .notNull(),
+  sortOrder: integer("sort_order").notNull().default(0),
+}, (table) => ({
+  entityBrandUnique: uniqueIndex("entity_brands_entity_brand_unique").on(table.entityId, table.brandId),
+}));
+
+export const optionTypes = pgTable("option_types", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  entityId: uuid("entity_id")
+    .references(() => sellableEntities.id, { onDelete: "cascade" })
+    .notNull(),
+  name: text("name").notNull(),
+  displayName: text("display_name").notNull(),
+  sortOrder: integer("sort_order").notNull().default(0),
+});
+
+export const optionValues = pgTable("option_values", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  optionTypeId: uuid("option_type_id")
+    .references(() => optionTypes.id, { onDelete: "cascade" })
+    .notNull(),
+  value: text("value").notNull(),
+  displayValue: text("display_value").notNull(),
+  sortOrder: integer("sort_order").notNull().default(0),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+});
+
+export const variants = pgTable("variants", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  entityId: uuid("entity_id")
+    .references(() => sellableEntities.id, { onDelete: "cascade" })
+    .notNull(),
+  sku: text("sku").unique(),
+  barcode: text("barcode"),
+  status: text("status", { enum: ["active", "discontinued"] })
+    .notNull()
+    .default("active"),
+  sortOrder: integer("sort_order").notNull().default(0),
+  metadata: jsonb("metadata").$type<Record<string, unknown>>().default({}),
+}, (table) => ({
+  barcodeIdx: index("idx_variants_barcode").on(table.barcode),
+  skuIdx: index("idx_variants_sku").on(table.sku),
+}));
+
+export const variantOptionValues = pgTable("variant_option_values", {
+  variantId: uuid("variant_id")
+    .references(() => variants.id, { onDelete: "cascade" })
+    .notNull(),
+  optionValueId: uuid("option_value_id")
+    .references(() => optionValues.id, { onDelete: "cascade" })
+    .notNull(),
+}, (table) => ({
+  variantOptionValueUnique: uniqueIndex("variant_option_values_variant_option_unique").on(table.variantId, table.optionValueId),
+}));

package/src/modules/catalog/schemas.ts

@@ -0,0 +1,104 @@
+import { z } from "@hono/zod-openapi";
+
+// ─── Catalog Body Schemas (single source of truth) ──────────────────────────
+
+export const CreateEntityBodySchema = z.object({
+  type: z.string().openapi({ example: "physicalGood" }),
+  slug: z.string().openapi({ example: "my-product" }),
+  status: z.string().optional().openapi({ example: "draft" }),
+  basePrice: z.number().optional().openapi({ example: 29.99 }),
+  currency: z.string().optional().openapi({ example: "USD" }),
+  metadata: z.record(z.string(), z.unknown()).optional().openapi({ example: { title: "My Product" } }),
+  attributes: z.object({
+    locale: z.string().optional(),
+    title: z.string(),
+    subtitle: z.string().optional(),
+    description: z.string().optional(),
+    richDescription: z.record(z.string(), z.unknown()).optional(),
+    seoTitle: z.string().optional(),
+    seoDescription: z.string().optional(),
+  }).optional(),
+  customFields: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateEntityBody");
+
+export const UpdateEntityBodySchema = z.object({
+  slug: z.string().optional(),
+  status: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  isVisible: z.boolean().optional(),
+}).openapi("UpdateEntityBody");
+
+export const SetAttributesBodySchema = z.record(z.string(), z.unknown()).openapi("SetAttributesBody");
+
+export const CreateCategoryBodySchema = z.object({
+  slug: z.string().openapi({ example: "shoes" }),
+  parentId: z.uuid().optional(),
+  sortOrder: z.number().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateCategoryBody");
+
+export const UpdateCategoryBodySchema = z.object({
+  slug: z.string().optional(),
+  parentId: z.uuid().nullable().optional(),
+  sortOrder: z.number().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("UpdateCategoryBody");
+
+export const CreateBrandBodySchema = z.object({
+  slug: z.string().openapi({ example: "nike" }),
+  displayName: z.string().openapi({ example: "Nike" }),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateBrandBody");
+
+export const UpdateBrandBodySchema = z.object({
+  slug: z.string().optional(),
+  displayName: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("UpdateBrandBody");
+
+export const CreateOptionTypeBodySchema = z.object({
+  name: z.string().openapi({ example: "Color" }),
+  values: z.array(z.string()).optional().openapi({ example: ["Red", "Blue"] }),
+}).openapi("CreateOptionTypeBody");
+
+export const CreateOptionValueBodySchema = z.object({
+  value: z.string().openapi({ example: "Green" }),
+}).openapi("CreateOptionValueBody");
+
+export const CreateVariantBodySchema = z.object({
+  sku: z.string().optional().openapi({ example: "SKU-001" }),
+  options: z.record(z.string(), z.string()).openapi({ example: { Color: "Red" } }),
+  price: z.number().optional().openapi({ example: 34.99 }),
+}).openapi("CreateVariantBody");
+
+export const GenerateVariantsBodySchema = z.object({}).passthrough().openapi("GenerateVariantsBody");
+
+// ─── Derived Input Types ─────────────────────────────────────────────────────
+
+export type CreateEntityInput = z.infer<typeof CreateEntityBodySchema>;
+
+export type UpdateEntityInput = z.infer<typeof UpdateEntityBodySchema>;
+
+export type CreateCategoryInput = z.infer<typeof CreateCategoryBodySchema> & {
+  id?: string;
+};
+
+export type UpdateCategoryInput = z.infer<typeof UpdateCategoryBodySchema>;
+
+export type CreateBrandInput = z.infer<typeof CreateBrandBodySchema> & {
+  id?: string;
+};
+
+export type UpdateBrandInput = z.infer<typeof UpdateBrandBodySchema>;
+
+export type CreateOptionTypeInput = z.infer<typeof CreateOptionTypeBodySchema> & {
+  entityId: string;
+};
+
+export type CreateOptionValueInput = z.infer<typeof CreateOptionValueBodySchema> & {
+  optionTypeId: string;
+};
+
+export type CreateVariantInput = z.infer<typeof CreateVariantBodySchema> & {
+  entityId: string;
+};

package/src/modules/catalog/service.ts

@@ -0,0 +1,392 @@
+import type { Actor } from "../../auth/types.js";
+import type { CommerceConfig } from "../../config/types.js";
+import type { HookRegistry } from "../../kernel/hooks/registry.js";
+import type { Result } from "../../kernel/result.js";
+import type { Pagination } from "../../utils/pagination.js";
+import type { DatabaseAdapter } from "../../kernel/database/adapter.js";
+import type { TxContext } from "../../kernel/database/tx-context.js";
+import {
+  CatalogRepository,
+  type SellableEntity,
+  type SellableAttribute,
+  type EntityCategory,
+  type EntityBrand,
+  type Brand,
+  type OptionType,
+  type OptionValue,
+  type Variant,
+} from "./repository/index.js";
+
+// ─── Re-exported schema-derived types ────────────────────────────────────────
+export type {
+  CreateEntityInput,
+  UpdateEntityInput,
+  CreateCategoryInput,
+  UpdateCategoryInput,
+  CreateBrandInput,
+  UpdateBrandInput,
+  CreateOptionTypeInput,
+  CreateOptionValueInput,
+  CreateVariantInput,
+} from "./schemas.js";
+
+import type {
+  CreateEntityInput,
+  UpdateEntityInput,
+  CreateCategoryInput,
+  UpdateCategoryInput,
+  CreateBrandInput,
+  UpdateBrandInput,
+  CreateOptionTypeInput,
+  CreateOptionValueInput,
+  CreateVariantInput,
+} from "./schemas.js";
+
+import { EntityService } from "./entity-service.js";
+import { CategoryService } from "./category-service.js";
+import { BrandService } from "./brand-service.js";
+
+// ─── Hand-written types (not derivable from a single z.infer) ───────────────
+
+export interface SetAttributesInput {
+  title: string;
+  subtitle?: string;
+  description?: string;
+  richDescription?: unknown;
+  seoTitle?: string;
+  seoDescription?: string;
+}
+
+export interface ListParams {
+  filter?: {
+    type?: string;
+    status?: string;
+    category?: string;
+    brand?: string;
+    customField?: {
+      fieldName: string;
+      value: unknown;
+    };
+  };
+  sort?: {
+    field: "createdAt" | "updatedAt" | "slug";
+    direction: "asc" | "desc";
+  };
+  pagination?: {
+    page: number;
+    limit: number;
+  };
+}
+
+export interface GetOptions {
+  includeAttributes?: boolean | { locales: string[] };
+  includeVariants?: boolean;
+  includeOptionTypes?: boolean;
+  includePricing?: boolean;
+  includeInventory?: boolean;
+  includeMedia?: boolean;
+  includeCategories?: boolean;
+  includeBrands?: boolean;
+}
+
+export interface VariantMatrixRule {
+  include?: string[][];
+  exclude?: string[][];
+}
+
+export type VariantGenerationStrategy =
+  | { mode: "all" }
+  | { mode: "manual"; combinations: string[][] }
+  | { mode: "matrix"; matrix: VariantMatrixRule };
+
+export interface CatalogEntityHydrated extends SellableEntity {
+  attributes?: SellableAttribute[];
+  variants?: Array<Variant & { optionValueIds: string[] }>;
+  optionTypes?: Array<OptionType & { values: OptionValue[] }>;
+  categories?: EntityCategory[];
+  brands?: EntityBrand[];
+  media?: Array<{ mediaAssetId: string; role: string; variantId?: string }>;
+  pricing?: Array<{ currency: string; amount: number; compareAtAmount?: number | null }>;
+}
+
+export interface CatalogService {
+  readonly repository: CatalogRepository;
+  create(
+    input: CreateEntityInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  update(
+    id: string,
+    input: UpdateEntityInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  delete(
+    id: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  getById(
+    id: string,
+    options?: GetOptions,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  getBySlug(
+    slug: string,
+    options?: GetOptions,
+    actor?: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  list(params: ListParams, actor?: Actor | null, ctx?: TxContext): Promise<Result<CatalogListResult>>;
+  publish(
+    id: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  archive(
+    id: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  discontinue(
+    id: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CatalogEntityHydrated>>;
+  setAttributes(
+    entityId: string,
+    locale: string,
+    attrs: SetAttributesInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  getAttributes(
+    entityId: string,
+    locale: string,
+    ctx?: TxContext,
+  ): Promise<Result<SellableAttribute>>;
+  listCategories(ctx?: TxContext): Promise<Result<CategorySummary[]>>;
+  createCategory(
+    input: CreateCategoryInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CategorySummary>>;
+  updateCategory(
+    id: string,
+    input: UpdateCategoryInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<CategorySummary>>;
+  deleteCategory(
+    id: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  addToCategory(
+    entityId: string,
+    categoryId: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  removeFromCategory(
+    entityId: string,
+    categoryId: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  listBrands(ctx?: TxContext): Promise<Result<Brand[]>>;
+  createBrand(
+    input: CreateBrandInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Brand>>;
+  updateBrand(
+    id: string,
+    input: UpdateBrandInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Brand>>;
+  deleteBrand(
+    id: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  addToBrand(
+    entityId: string,
+    brandId: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  removeFromBrand(
+    entityId: string,
+    brandId: string,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<void>>;
+  createOptionType(
+    input: CreateOptionTypeInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<OptionType>>;
+  createOptionValue(
+    input: CreateOptionValueInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<OptionValue>>;
+  createVariant(
+    input: CreateVariantInput,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Variant>>;
+  generateVariants(
+    entityId: string,
+    strategy: VariantGenerationStrategy,
+    actor: Actor | null,
+    ctx?: TxContext,
+  ): Promise<Result<Variant[]>>;
+}
+
+export interface CatalogServiceDeps {
+  repository: CatalogRepository;
+  hooks: HookRegistry;
+  config: CommerceConfig;
+  services: Record<string, unknown>;
+  database: DatabaseAdapter;
+}
+
+export type CatalogListResult = {
+  items: CatalogEntityHydrated[];
+  pagination: Pagination;
+};
+
+export type CategorySummary = {
+  id: string;
+  parentId?: string | null;
+  slug: string;
+  sortOrder: number;
+  metadata: Record<string, unknown>;
+};
+
+export class CatalogServiceImpl implements CatalogService {
+  readonly repository: CatalogRepository;
+  private readonly entities: EntityService;
+  private readonly categories: CategoryService;
+  private readonly brands: BrandService;
+
+  constructor(deps: CatalogServiceDeps) {
+    this.repository = deps.repository;
+    this.entities = new EntityService(deps);
+    this.categories = new CategoryService(deps);
+    this.brands = new BrandService(deps);
+  }
+
+  create(input: CreateEntityInput, actor: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.create(input, actor, ctx);
+  }
+
+  update(id: string, input: UpdateEntityInput, actor: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.update(id, input, actor, ctx);
+  }
+
+  delete(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.entities.delete(id, actor, ctx);
+  }
+
+  getById(id: string, options?: GetOptions, actor?: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.getById(id, options, actor, ctx);
+  }
+
+  getBySlug(slug: string, options?: GetOptions, actor?: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.getBySlug(slug, options, actor, ctx);
+  }
+
+  list(params: ListParams, actor?: Actor | null, ctx?: TxContext): Promise<Result<CatalogListResult>> {
+    return this.entities.list(params, actor, ctx);
+  }
+
+  publish(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.publish(id, actor, ctx);
+  }
+
+  archive(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.archive(id, actor, ctx);
+  }
+
+  discontinue(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<CatalogEntityHydrated>> {
+    return this.entities.discontinue(id, actor, ctx);
+  }
+
+  setAttributes(entityId: string, locale: string, attrs: SetAttributesInput, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.entities.setAttributes(entityId, locale, attrs, actor, ctx);
+  }
+
+  getAttributes(entityId: string, locale: string, ctx?: TxContext): Promise<Result<SellableAttribute>> {
+    return this.entities.getAttributes(entityId, locale, ctx);
+  }
+
+  listCategories(ctx?: TxContext): Promise<Result<CategorySummary[]>> {
+    return this.categories.listCategories(ctx);
+  }
+
+  createCategory(input: CreateCategoryInput, actor: Actor | null, ctx?: TxContext): Promise<Result<CategorySummary>> {
+    return this.categories.createCategory(input, actor, ctx);
+  }
+
+  updateCategory(id: string, input: UpdateCategoryInput, actor: Actor | null, ctx?: TxContext): Promise<Result<CategorySummary>> {
+    return this.categories.updateCategory(id, input, actor, ctx);
+  }
+
+  deleteCategory(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.categories.deleteCategory(id, actor, ctx);
+  }
+
+  addToCategory(entityId: string, categoryId: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.categories.addToCategory(entityId, categoryId, actor, ctx);
+  }
+
+  removeFromCategory(entityId: string, categoryId: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.categories.removeFromCategory(entityId, categoryId, actor, ctx);
+  }
+
+  listBrands(ctx?: TxContext): Promise<Result<Brand[]>> {
+    return this.brands.listBrands(ctx);
+  }
+
+  createBrand(input: CreateBrandInput, actor: Actor | null, ctx?: TxContext): Promise<Result<Brand>> {
+    return this.brands.createBrand(input, actor, ctx);
+  }
+
+  updateBrand(id: string, input: UpdateBrandInput, actor: Actor | null, ctx?: TxContext): Promise<Result<Brand>> {
+    return this.brands.updateBrand(id, input, actor, ctx);
+  }
+
+  deleteBrand(id: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.brands.deleteBrand(id, actor, ctx);
+  }
+
+  addToBrand(entityId: string, brandId: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.brands.addToBrand(entityId, brandId, actor, ctx);
+  }
+
+  removeFromBrand(entityId: string, brandId: string, actor: Actor | null, ctx?: TxContext): Promise<Result<void>> {
+    return this.brands.removeFromBrand(entityId, brandId, actor, ctx);
+  }
+
+  createOptionType(input: CreateOptionTypeInput, actor: Actor | null, ctx?: TxContext): Promise<Result<OptionType>> {
+    return this.entities.createOptionType(input, actor, ctx);
+  }
+
+  createOptionValue(input: CreateOptionValueInput, actor: Actor | null, ctx?: TxContext): Promise<Result<OptionValue>> {
+    return this.entities.createOptionValue(input, actor, ctx);
+  }
+
+  createVariant(input: CreateVariantInput, actor: Actor | null, ctx?: TxContext): Promise<Result<Variant>> {
+    return this.entities.createVariant(input, actor, ctx);
+  }
+
+  generateVariants(entityId: string, strategy: VariantGenerationStrategy, actor: Actor | null, ctx?: TxContext): Promise<Result<Variant[]>> {
+    return this.entities.generateVariants(entityId, strategy, actor, ctx);
+  }
+}

package/src/modules/customers/index.ts

@@ -0,0 +1 @@
+export { customersModule } from "./module.js";