@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/Subscriber.ts

@@ -0,0 +1,89 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Subscriber',
+  table: 'subscribers',
+  primaryKey: 'id',
+  autoIncrement: true,
+  belongsTo: ['User'],
+  hasMany: ['SubscriberEmail', 'EmailListSubscriber', 'CampaignSend'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: {
+      count: 10,
+    },
+    useApi: {
+      uri: 'subscribers',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      // Subscriber rows are PII (email + status + source). Auth-gate
+      // every CRUD route. The public signup path is the dedicated
+      // `/api/email/subscribe` action — that has its own rate-limited,
+      // CSRF-skipped handler that wraps `Subscriber.create()`. Apps
+      // that want public destroy (one-click unsubscribe) should use
+      // the existing `/api/email/unsubscribe` UUID-token route, not
+      // expose `DELETE /api/subscribers/{id}`.
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    email: {
+      unique: true,
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().max(255),
+        message: {
+          string: 'email must be a string',
+          required: 'email is required',
+          email: 'email must be a valid email address',
+          max: 'email must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'subscribed',
+      validation: {
+        rule: schema.enum(['subscribed', 'unsubscribed', 'pending', 'bounced']),
+        message: {
+          enum: 'status must be one of: subscribed, unsubscribed, pending, bounced',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['subscribed', 'subscribed', 'subscribed', 'unsubscribed', 'pending']),
+    },
+
+    source: {
+      required: false,
+      fillable: true,
+      default: 'homepage',
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          string: 'source must be a string',
+          max: 'source must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['homepage', 'blog', 'landing-page', 'api', 'import']),
+    },
+
+    // Set when the subscriber globally unsubscribes via the legacy
+    // /api/email/unsubscribe?token=<uuid> route. Per-list unsubscribe
+    // state (the modern flow) lives on `email_list_subscribers` so a
+    // user can drop "Weekly Digest" without losing transactional mail.
+    unsubscribedAt: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+  },
+} as const)

package/dist/models/SubscriberEmail.ts

@@ -0,0 +1,55 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'SubscriberEmail',
+  table: 'subscriber_emails',
+  primaryKey: 'id',
+  autoIncrement: true,
+  belongsTo: ['Subscriber'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: {
+      uri: 'subscriber-emails',
+      routes: ['index', 'show'],
+      // SubscriberEmail rows are PII (email + signup source). Without
+      // this gate, anyone can scrape the list at GET /api/subscriber-emails.
+      // Apps that genuinely want a public list (e.g. a transparency
+      // page) can override the model in `app/Models/`.
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    email: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().max(255),
+        message: {
+          string: 'email must be a string',
+          required: 'email is required',
+          email: 'email must be a valid email address',
+          max: 'email must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    source: {
+      required: false,
+      fillable: true,
+      default: 'homepage',
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          string: 'source must be a string',
+          max: 'source must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['homepage', 'blog', 'landing-page', 'api', 'import']),
+    },
+  },
+} as const)

package/dist/models/Subscription.ts

@@ -0,0 +1,153 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Subscription', // defaults to the sanitized file name
+  table: 'subscriptions', // defaults to the lowercase, plural name of the model name (or the name of the model file)
+  primaryKey: 'id', // defaults to `id`
+  autoIncrement: true, // defaults to true
+  belongsTo: ['User'],
+  traits: {
+    useUuid: true,
+  },
+  attributes: {
+    type: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(512),
+        message: {
+          string: 'type must be a string',
+          required: 'type is required',
+          max: 'type must have a maximum of 512 characters',
+        },
+      },
+      factory: faker => faker.lorem.lines(1),
+    },
+
+    plan: {
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          string: 'plan must be a string',
+          required: 'plan is required',
+          max: 'plan must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['free', 'starter', 'pro', 'enterprise']),
+    },
+
+    providerId: {
+      unique: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          string: 'provider_id must be a string',
+          required: 'provider_id is required',
+          max: 'provider_id must have a maximum of 512 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric(10),
+    },
+
+    providerStatus: {
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+        message: {
+          string: 'provider_status must be a string',
+          required: 'provider_status is required',
+        },
+      },
+      factory: faker => faker.string.alpha(10),
+    },
+    unitPrice: {
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+        message: {
+          string: 'unit_price must be a number',
+          required: 'unit_price is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1000, max: 10000 }),
+    },
+
+    providerType: {
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255).required(),
+        message: {
+          string: 'provider_type must be a string',
+          required: 'provider_type is required',
+        },
+      },
+      factory: faker => faker.string.alpha(10),
+    },
+
+    providerPriceId: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'provider_price_id must be a string',
+        },
+      },
+      factory: faker => faker.commerce.price(),
+    },
+
+    quantity: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          number: 'quantity must be a number',
+        },
+      },
+      factory: faker => faker.number.int(100),
+    },
+
+    trialEndsAt: {
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'trial_ends_at must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    endsAt: {
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'ends_at must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    lastUsedAt: {
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'last_used_at must be a valid timestamp',
+        },
+      },
+      fillable: true,
+      factory: (faker) => {
+        const date = faker.date.recent()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+  },
+} as const)

package/dist/models/Tag.ts

@@ -0,0 +1,105 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+const tagNames = [
+  'javascript',
+  'typescript',
+  'stx',
+  'react',
+  'nodejs',
+  'database',
+  'performance',
+  'security',
+  'api',
+  'testing',
+  'devops',
+  'cloud',
+  'frontend',
+  'backend',
+  'mobile',
+]
+
+export default defineModel({
+  name: 'Tag',
+  table: 'tags',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: {
+      count: tagNames.length,
+      fixtures: tagNames.map(name => ({ name, slug: name })),
+    },
+    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: 'tags',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+    },
+  },
+
+  belongsToMany: {
+    posts: {
+      model: 'Post',
+      table: 'taggable_models',
+      foreignKey: 'tag_id',
+      relatedKey: 'taggable_id',
+      pivot: {
+        columns: {
+          taggable_type: { default: 'posts' },
+        },
+        timestamps: true,
+        uniques: [['tag_id', 'taggable_id', 'taggable_type']],
+      },
+    },
+  },
+
+  attributes: {
+    name: {
+      required: true,
+      unique: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(50),
+        message: {
+          min: 'Tag name must have at least 2 characters',
+          max: 'Tag name must have at most 50 characters',
+        },
+      },
+      factory: faker => `tag-${faker.string.alphanumeric(12).toLowerCase()}`,
+    },
+
+    slug: {
+      required: true,
+      unique: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(50),
+      },
+      factory: faker => `tag-${faker.string.alphanumeric(12).toLowerCase()}`,
+    },
+
+    description: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    color: {
+      required: false,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(20),
+      },
+      factory: faker => faker.helpers.arrayElement(['blue', 'green', 'red', 'purple', 'yellow', 'orange', 'pink', 'gray']),
+    },
+  },
+} as const)

package/dist/models/Team.ts

@@ -0,0 +1,75 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Team',
+  table: 'teams',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'description', 'memberCount', 'createdAt'],
+      searchable: ['name', 'description'],
+      sortable: ['name', 'createdAt', 'updatedAt', 'memberCount'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 5,
+    },
+
+    useApi: {
+      uri: 'teams',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  hasMany: ['TeamMember', 'TeamInvitation'],
+
+  attributes: {
+    name: {
+      order: 1,
+      unique: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(2).max(100),
+      },
+      factory: faker => faker.company.name(),
+    },
+
+    description: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.company.catchPhrase(),
+    },
+
+    memberCount: {
+      order: 3,
+      fillable: false,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+
+    status: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/TeamInvitation.ts

@@ -0,0 +1,159 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A single-use invitation to join a team.
+ *
+ * The raw bearer token is only returned by the dedicated invite action and
+ * sent to the recipient. This model stores its SHA-256 digest so generated
+ * API responses and database reads cannot leak a usable invitation.
+ */
+export default defineModel({
+  name: 'TeamInvitation',
+  table: 'team_invitations',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'team_invitations_token_hash_unique',
+      columns: ['token_hash'],
+      unique: true,
+    },
+    {
+      name: 'team_invitations_pending_key_unique',
+      columns: ['pending_key'],
+      unique: true,
+    },
+    {
+      name: 'team_invitations_team_email_status_index',
+      columns: ['team_id', 'email', 'status'],
+    },
+  ],
+
+  belongsTo: ['Team'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: { count: 0 },
+    useSearch: {
+      displayable: ['id', 'teamId', 'email', 'role', 'status', 'deliveryStatus', 'expiresAt', 'createdAt'],
+      searchable: ['email'],
+      sortable: ['email', 'role', 'status', 'expiresAt', 'createdAt', 'updatedAt'],
+      filterable: ['teamId', 'role', 'status', 'deliveryStatus'],
+    },
+    useApi: {
+      uri: 'team-invitations',
+      routes: ['index', 'show', 'destroy'],
+      middleware: ['auth', 'team'],
+    },
+  },
+
+  attributes: {
+    teamId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+    },
+
+    email: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required().max(320),
+      },
+    },
+
+    role: {
+      required: true,
+      fillable: true,
+      default: 'member',
+      validation: {
+        rule: schema.enum(['admin', 'member', 'viewer']),
+      },
+    },
+
+    tokenHash: {
+      required: true,
+      hidden: true,
+      validation: {
+        rule: schema.string().required().max(64),
+      },
+    },
+
+    pendingKey: {
+      required: false,
+      hidden: true,
+      validation: {
+        rule: schema.string().max(384),
+      },
+    },
+
+    invitedByUserId: {
+      required: false,
+      validation: {
+        rule: schema.number(),
+      },
+    },
+
+    acceptedByUserId: {
+      required: false,
+      validation: {
+        rule: schema.number(),
+      },
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'accepted', 'revoked', 'expired']),
+      },
+    },
+
+    deliveryStatus: {
+      required: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'sent', 'failed']),
+      },
+    },
+
+    deliveryError: {
+      required: false,
+      hidden: true,
+      validation: {
+        rule: schema.string().max(2000),
+      },
+    },
+
+    expiresAt: {
+      required: true,
+      validation: {
+        rule: schema.timestamp().required(),
+      },
+    },
+
+    deliveredAt: {
+      required: false,
+      validation: {
+        rule: schema.timestamp(),
+      },
+    },
+
+    acceptedAt: {
+      required: false,
+      validation: {
+        rule: schema.timestamp(),
+      },
+    },
+  },
+
+  dashboard: {
+    enabled: false,
+  },
+} as const)