@stacksjs/defaults 0.70.58 → 0.70.59

package/app/Models/commerce/DeliveryRoute.ts

@@ -0,0 +1,93 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'DeliveryRoute',
+  table: 'delivery_routes',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'driver', 'vehicle', 'stops', 'deliveryTime', 'totalDistance', 'lastActive'],
+      searchable: ['driver', 'vehicle'],
+      sortable: ['stops', 'deliveryTime', 'totalDistance', 'lastActive', 'createdAt', 'updatedAt'],
+      filterable: ['driver', 'vehicle'],
+    },
+
+    useSeeder: {
+      count: 5,
+    },
+
+    useApi: {
+      uri: 'delivery-routes',
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    driver: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    vehicle: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.vehicle.vehicle(),
+    },
+
+    stops: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 20 }),
+    },
+
+    deliveryTime: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 30, max: 480 }), // 30 minutes to 8 hours
+    },
+
+    totalDistance: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 5, max: 200 }), // 5 to 200 miles
+    },
+
+    lastActive: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp().required(),
+      },
+      factory: (faker) => {
+        const date = faker.date.recent()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/DigitalDelivery.ts

@@ -0,0 +1,105 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'DigitalDelivery',
+  table: 'digital_deliveries',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'description', 'downloadLimit', 'expiryDays', 'status'],
+      searchable: ['name', 'description'],
+      sortable: ['name', 'downloadLimit', 'expiryDays', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'digital-deliveries',
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    name: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    description: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.commerce.productDescription(),
+    },
+
+    downloadLimit: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 100 }),
+    },
+
+    expiryDays: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 365 }),
+    },
+
+    requiresLogin: {
+      default: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean(),
+    },
+
+    automaticDelivery: {
+      default: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean(),
+    },
+
+    status: {
+      default: 'active',
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/Driver.ts

@@ -0,0 +1,97 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Driver',
+  table: 'drivers',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  belongsTo: ['User'],
+  hasMany: ['DeliveryRoute'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'phone', 'vehicleNumber', 'license', 'status'],
+      searchable: ['name', 'phone', 'vehicleNumber', 'license'],
+      sortable: ['name', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'drivers',
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    phone: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Phone number must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    vehicleNumber: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Vehicle number must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.vehicle.vrm(),
+    },
+
+    license: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'License number must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric({ length: 10, casing: 'upper' }),
+    },
+
+    status: {
+      default: 'active',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'on_delivery', 'on_break']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'on_delivery', 'on_break']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/GiftCard.ts

@@ -0,0 +1,191 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'GiftCard',
+  table: 'gift_cards',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'code', 'initialBalance', 'currentBalance', 'status', 'expiryDate', 'isActive'],
+      searchable: ['code', 'recipientName', 'recipientEmail', 'purchaserId'],
+      sortable: ['createdAt', 'expiryDate', 'initialBalance', 'currentBalance'],
+      filterable: ['status', 'isDigital', 'isReloadable', 'isActive'],
+    },
+
+    useSeeder: {
+      count: 20,
+    },
+
+    useApi: {
+      uri: 'gift-cards',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Customer'],
+  hasMany: ['Order'],
+
+  attributes: {
+    code: {
+      unique: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+        message: {
+          max: 'Code must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric(12).toUpperCase(),
+    },
+
+    initialBalance: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 100, max: 2000 }),
+    },
+
+    currentBalance: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: () => 1,
+    },
+
+    currency: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(3),
+      },
+      factory: faker => faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'CAD', 'AUD']),
+    },
+
+    status: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['ACTIVE', 'USED', 'EXPIRED', 'DEACTIVATED']),
+    },
+
+    purchaser_id: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    recipient_email: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().email(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.internet.email(), { probability: 0.7 }),
+    },
+
+    recipientName: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.person.fullName(), { probability: 0.6 }),
+    },
+
+    personalMessage: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.lorem.sentence(), { probability: 0.4 }),
+    },
+
+    isDigital: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.8 }), // 80% digital
+    },
+
+    isReloadable: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.3 }), // 30% reloadable
+    },
+
+    isActive: {
+      order: 12,
+      fillable: true,
+      default: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.9 }), // 90% active
+    },
+
+    expiryDate: {
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'Expiry date must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    lastUsedDate: {
+      order: 14,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'Last used date must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    templateId: {
+      order: 15,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.uuid(), { probability: 0.5 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/LicenseKey.ts

@@ -0,0 +1,87 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'LicenseKey',
+  table: 'license_keys',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'key', 'template', 'expiryDate', 'status'],
+      searchable: ['key'],
+      sortable: ['template', 'expiryDate', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status', 'template'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'license-keys',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Customer', 'Product', 'Order'],
+
+  attributes: {
+    key: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+        message: {
+          pattern: 'License key must be in the format XXXX-XXXX-XXXX-XXXX-XXXX',
+        },
+      },
+      factory: (faker) => {
+        const generateBlock = () => faker.string.alphanumeric({ length: 4, casing: 'upper' })
+        return `${generateBlock()}-${generateBlock()}-${generateBlock()}-${generateBlock()}-${generateBlock()}`
+      },
+    },
+
+    template: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['Standard License', 'Premium License', 'Enterprise License']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['Standard License', 'Premium License', 'Enterprise License']),
+    },
+
+    expiryDate: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp().required(),
+        message: {
+          timestamp: 'Expiry date must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    status: {
+      default: 'unassigned',
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'unassigned']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive', 'unassigned']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/LoyaltyPoint.ts

@@ -0,0 +1,107 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'LoyaltyPoint',
+  table: 'loyalty_points',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'walletId', 'points', 'source', 'description', 'expiryDate', 'isUsed'],
+      searchable: ['description', 'source', 'sourceReferenceId'],
+      sortable: ['createdAt', 'points', 'expiryDate'],
+      filterable: ['walletId', 'source', 'isUsed'],
+    },
+
+    useSeeder: {
+      count: 50,
+    },
+
+    useApi: {
+      uri: 'loyalty-points',
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    walletId: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    points: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 500 }),
+    },
+
+    source: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.arrayElement(['ORDER', 'PROMOTION', 'REFERRAL', 'MANUAL']),
+    },
+
+    sourceReferenceId: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    description: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        `Points earned from order #${faker.string.alphanumeric(8).toUpperCase()}`,
+        `Bonus points from promotion`,
+        `Referral bonus for inviting a friend`,
+        `Manual adjustment by administrator`,
+      ]),
+    },
+
+    expiryDate: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    isUsed: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.3 }), // 30% chance of being used
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)