@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/Product.ts

@@ -0,0 +1,153 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Product',
+  table: 'products',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'description', 'price', 'categoryId', 'isAvailable', 'inventoryCount'],
+      searchable: ['name', 'description', 'categoryId'],
+      sortable: ['price', 'createdAt', 'updatedAt', 'inventoryCount', 'preparationTime'],
+      filterable: ['categoryId', 'isAvailable', 'allergens'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      // Public catalog: anyone may browse, only authenticated callers may
+      // write. Declared explicitly because the trait now defaults BOTH sides to
+      // `auth` — an undeclared read route is how a customer list leaks
+      // (stacksjs/stacks#2224). Behaviour here is unchanged.
+      middleware: { read: [], write: ['auth'] },
+      uri: 'products',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Category', 'Manufacturer'],
+
+  hasMany: ['Review', 'ProductUnit', 'ProductVariant', 'LicenseKey', 'WaitlistProduct', 'Coupon'],
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    description: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.commerce.productDescription(),
+    },
+
+    price: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          min: 'Price must be at least 1',
+        },
+      },
+      factory: faker => faker.number.int({ min: 100, max: 10000 }),
+    },
+
+    imageUrl: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'Image URL must be a string',
+        },
+      },
+      factory: faker => faker.image.url(),
+    },
+
+    isAvailable: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: () => true,
+    },
+
+    inventoryCount: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Inventory count must be at least 0',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    preparationTime: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          min: 'Preparation time must be at least 1 minute',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 60 }),
+    },
+
+    allergens: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: (faker) => {
+        const possibleAllergens = ['Gluten', 'Dairy', 'Nuts', 'Soy', 'Eggs', 'Fish', 'Shellfish']
+        const count = faker.number.int({ min: 0, max: 3 })
+        const allergens = faker.helpers.arrayElements(possibleAllergens, count)
+        return JSON.stringify(allergens)
+      },
+    },
+
+    nutritionalInfo: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: (faker) => {
+        return JSON.stringify({
+          calories: faker.number.int({ min: 50, max: 800 }),
+          fat: faker.number.float({ min: 0, max: 50 }),
+          protein: faker.number.float({ min: 0, max: 30 }),
+          carbs: faker.number.float({ min: 0, max: 100 }),
+        })
+      },
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/ProductUnit.ts

@@ -0,0 +1,113 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ProductUnit',
+  table: 'product_units',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'abbreviation', 'type', 'description', 'isDefault'],
+      searchable: ['name', 'abbreviation', 'type', 'description'],
+      sortable: ['name', 'type', 'createdAt', 'updatedAt'],
+      filterable: ['type', 'isDefault'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      // Public catalog: anyone may browse, only authenticated callers may
+      // write. Declared explicitly because the trait now defaults BOTH sides to
+      // `auth` — an undeclared read route is how a customer list leaks
+      // (stacksjs/stacks#2224). Behaviour here is unchanged.
+      middleware: { read: [], write: ['auth'] },
+      uri: 'product-units',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Product'],
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Name must have a maximum of 100 characters',
+        },
+      },
+      factory: (faker) => {
+        const units = ['Piece', 'Kilogram', 'Gram', 'Liter', 'Milliliter', 'Meter', 'Centimeter', 'Box', 'Pack', 'Pair']
+        return faker.helpers.arrayElement(units)
+      },
+    },
+
+    abbreviation: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(10),
+        message: {
+          max: 'Abbreviation must have a maximum of 10 characters',
+        },
+      },
+      factory: (faker) => {
+        const abbrs = ['pc', 'kg', 'g', 'L', 'mL', 'm', 'cm', 'box', 'pk', 'pr']
+        return faker.helpers.arrayElement(abbrs)
+      },
+    },
+
+    type: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+        message: {
+          string: 'Type must be a string',
+        },
+      },
+      factory: (faker) => {
+        const types = ['Weight', 'Volume', 'Length', 'Quantity', 'Size']
+        return faker.helpers.arrayElement(types)
+      },
+    },
+
+    description: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+        message: {
+          max: 'Description must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    isDefault: {
+      default: false,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+        message: {
+          boolean: 'Default status must be a boolean',
+        },
+      },
+      factory: () => false,
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/ProductVariant.ts

@@ -0,0 +1,111 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ProductVariant',
+  table: 'product_variants',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'productId', 'variant', 'type', 'description', 'options', 'status'],
+      searchable: ['variant', 'type', 'description', 'options'],
+      sortable: ['createdAt', 'updatedAt', 'variant', 'type', 'status'],
+      filterable: ['productId', 'type', 'status'],
+    },
+
+    useSeeder: {
+      count: 50,
+    },
+
+    useApi: {
+      // Public catalog: anyone may browse, only authenticated callers may
+      // write. Declared explicitly because the trait now defaults BOTH sides to
+      // `auth` — an undeclared read route is how a customer list leaks
+      // (stacksjs/stacks#2224). Behaviour here is unchanged.
+      middleware: { read: [], write: ['auth'] },
+      uri: 'product-variants',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Product'],
+
+  attributes: {
+    variant: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Variant name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.commerce.productAdjective(),
+    },
+
+    type: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+        message: {
+          max: 'Type must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['color', 'size', 'material', 'style', 'configuration']),
+    },
+
+    description: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.commerce.productDescription(),
+    },
+
+    options: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: (faker) => {
+        const optionTypes = {
+          color: ['Red', 'Blue', 'Green', 'Black', 'White', 'Yellow', 'Purple', 'Orange', 'Brown', 'Gray'],
+          size: ['XS', 'S', 'M', 'L', 'XL', 'XXL', '2XL', '3XL', '4XL'],
+          material: ['Cotton', 'Polyester', 'Wool', 'Silk', 'Leather', 'Metal', 'Wood', 'Plastic', 'Glass'],
+          style: ['Casual', 'Formal', 'Sport', 'Vintage', 'Modern', 'Classic', 'Bohemian', 'Minimalist'],
+          configuration: ['Standard', 'Deluxe', 'Premium', 'Basic', 'Pro', 'Ultimate', 'Limited Edition'],
+        }
+
+        const variantType = faker.helpers.arrayElement(Object.keys(optionTypes)) as keyof typeof optionTypes
+        const optionCount = faker.number.int({ min: 2, max: 5 })
+        const selectedOptions = faker.helpers.arrayElements(optionTypes[variantType], optionCount)
+
+        return JSON.stringify(selectedOptions)
+      },
+    },
+
+    status: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'draft']).required(),
+        message: {
+          enum: 'Status must be one of: active, inactive, draft',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive', 'draft']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Receipt.ts

@@ -0,0 +1,144 @@
+import type { Attributes } from '@stacksjs/types'
+import { defineModel, formatDate } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+function receiptTimestamp(value: unknown): string {
+  if (typeof value === 'number')
+    return formatDate(value <= 2147483647 ? value * 1000 : value)
+
+  if (typeof value === 'string' && /^\d{10}$/.test(value))
+    return formatDate(Number(value) * 1000)
+
+  return formatDate(value as Date | string)
+}
+
+export default defineModel({
+  name: 'Receipt',
+  table: 'receipts',
+  primaryKey: 'id',
+  autoIncrement: true,
+  belongsTo: ['PrintDevice'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'printer', 'document', 'timestamp', 'status', 'size', 'pages', 'duration'],
+      searchable: ['printer', 'document'],
+      sortable: ['timestamp', 'status', 'size', 'pages', 'duration'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 5,
+    },
+
+    useApi: {
+      uri: 'print-logs',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    printer: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          max: 'Printer name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.company.name(),
+    },
+
+    document: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Document name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.system.fileName(),
+    },
+
+    timestamp: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestampTz().required(),
+        message: {
+          invalid: 'Invalid date format',
+        },
+      },
+      factory: faker => faker.date.recent().toISOString(),
+    },
+
+    status: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['success', 'failed', 'warning']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['success', 'failed', 'warning']),
+    },
+
+    size: {
+      default: 0,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(100),
+        message: {
+          max: 'Size must be less than or equal to 100',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 100 }),
+    },
+
+    pages: {
+      default: 0,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(50),
+        message: {
+          max: 'Pages must be less than or equal to 50',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 50 }),
+    },
+
+    duration: {
+      default: 0,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(50),
+        message: {
+          max: 'Duration must be less than or equal to 50',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 50 }),
+    },
+    metadata: {
+      order: 8,
+      fillable: true,
+      default: '{}',
+      validation: {
+        rule: schema.string(),
+      },
+    },
+  },
+
+  set: {
+    timestamp: (attributes: Attributes) => receiptTimestamp(attributes.timestamp),
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Review.ts

@@ -0,0 +1,171 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Review',
+  table: 'reviews',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'productId', 'rating', 'title', 'content', 'isVerifiedPurchase', 'isApproved'],
+      searchable: ['title', 'content', 'productId'],
+      sortable: ['rating', 'createdAt', 'updatedAt', 'helpfulVotes'],
+      filterable: ['productId', 'rating', 'isVerifiedPurchase', 'isApproved'],
+    },
+
+    useSeeder: {
+      count: 50,
+    },
+
+    useApi: {
+      uri: 'product-reviews',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Product', 'Customer'],
+
+  attributes: {
+    /**
+     * One to five stars, or absent.
+     *
+     * A review is a rating, a written comment, or both, and which of those a
+     * shop asks for is the shop's decision - some want a star out of a
+     * one-tap prompt, some want prose from a verified buyer, most want either.
+     * `required()` here made the first and third impossible: a comment with no
+     * star failed validation, so a store that wanted written feedback had to
+     * invent a rating to carry it and then filter that invention back out of
+     * its own averages.
+     *
+     * The column has always been nullable; only this rule disagreed. Null means
+     * "not rated" and is excluded from an average rather than counted as zero -
+     * see `fetchStats` in commerce/products/reviews.
+     *
+     * `store()` enforces the other half of the rule: a review with neither a
+     * rating nor content is not a review, and is rejected there because a
+     * cross-field check cannot be expressed on a single attribute.
+     */
+    rating: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1).max(5),
+        message: {
+          min: 'Rating must be at least 1',
+          max: 'Rating cannot be more than 5',
+        },
+      },
+      // Roughly one in six is a comment with no star, so seeded data exercises
+      // the unrated path rather than only ever the happy one.
+      factory: faker => faker.datatype.boolean({ probability: 0.84 })
+        ? faker.number.int({ min: 1, max: 5 })
+        : null,
+    },
+
+    title: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          max: 'Title must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.lorem.sentence({ min: 3, max: 8 }),
+    },
+
+    content: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2000),
+        message: {
+          max: 'Review content must have a maximum of 2000 characters',
+        },
+      },
+      // And roughly one in five is a bare star with nothing written, which is
+      // what a one-tap rating prompt produces.
+      factory: faker => faker.datatype.boolean({ probability: 0.8 })
+        ? faker.lorem.paragraphs({ min: 1, max: 3 })
+        : '',
+    },
+
+    isVerifiedPurchase: {
+      default: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.7 }),
+    },
+
+    isApproved: {
+      default: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.9 }),
+    },
+
+    isFeatured: {
+      default: false,
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.9 }),
+    },
+
+    helpfulVotes: {
+      order: 9,
+      default: 0,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 200 }),
+    },
+
+    unhelpfulVotes: {
+      order: 10,
+      default: 0,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50 }),
+    },
+
+    purchaseDate: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.date.past({ years: 1 }).toISOString(),
+    },
+
+    images: {
+      order: 12,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: () => 'test',
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)