@unifiedcommerce/core 0.1.0 → 0.2.0

package/src/modules/catalog/schema.ts

@@ -1,203 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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;
-};