@stacksjs/orm 0.72.16 → 0.72.17

package/dist/models/QueryLog.ts

@@ -0,0 +1,182 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'QueryLog',
+  table: 'query_logs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'query_logs_executed_at_index',
+      columns: ['executed_at'],
+    },
+    {
+      name: 'query_logs_status_index',
+      columns: ['status'],
+    },
+    {
+      name: 'query_logs_duration_index',
+      columns: ['duration'],
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useApi: {
+      uri: 'query-logs',
+      routes: ['index', 'show'],
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    query: {
+      required: true,
+      fillable: true,
+      type: 'text',
+      validation: {
+        rule: schema.string().required(),
+      },
+    },
+    normalized_query: {
+      fillable: true,
+      type: 'text',
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    duration: {
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+    connection: {
+      fillable: true,
+      default: 'unknown',
+      validation: {
+        rule: schema.string().max(255),
+      },
+    },
+    status: {
+      fillable: true,
+      default: 'completed',
+      validation: {
+        rule: schema.enum(['completed', 'failed', 'slow']),
+      },
+    },
+    error: {
+      fillable: true,
+      type: 'text',
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    executed_at: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+    },
+    bindings: {
+      hidden: true,
+      fillable: true,
+      type: 'text',
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    trace: {
+      hidden: true,
+      fillable: true,
+      type: 'text',
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    model: {
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+    },
+    method: {
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+    },
+    file: {
+      hidden: true,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    line: {
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+    memory_usage: {
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+    rows_affected: {
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+    transaction_id: {
+      fillable: true,
+      foreignKey: false,
+      validation: {
+        rule: schema.string().max(255),
+      },
+    },
+    tags: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    affected_tables: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    indexes_used: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    missing_indexes: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    explain_plan: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+    optimization_suggestions: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+    },
+  },
+} as const)

package/dist/models/README.md

@@ -0,0 +1,31 @@
+# What are Models
+
+Models are a way to define the structure of your data. They are used to interact with your database, and can be used to define relationships between different types of data.
+
+## Get Started
+
+The following command will bootstrap a new model in the `app/Models` directory.
+
+```sh
+buddy make:model User
+```
+
+## 🚜 Contributing
+
+Please review the [Contributing Guide](https://github.com/stacksjs/contributing) for details.
+
+## 🏝 Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/stacks/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://stacksjs.com/discord)
+
+## 📄 License
+
+The MIT License (MIT). Please see [LICENSE](../../LICENSE.md) for more information.
+
+Made with 💙

package/dist/models/Release.ts

@@ -0,0 +1,90 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Release',
+  table: 'releases',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'version', 'type', 'status', 'createdAt'],
+      searchable: ['version', 'type', 'notes'],
+      sortable: ['createdAt', 'version'],
+      filterable: ['type', 'status'],
+    },
+
+    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: 'releases',
+      routes: ['index', 'show'],
+    },
+  },
+
+  attributes: {
+    version: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+      },
+      factory: faker => faker.system.semver(),
+    },
+
+    type: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['major', 'minor', 'patch']),
+    },
+
+    status: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['published', 'draft', 'scheduled']),
+    },
+
+    notes: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    downloads: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50000 }),
+    },
+
+    author: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.person.fullName(),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/Request.ts

@@ -0,0 +1,133 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Request',
+  table: 'requests',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'requests_created_at_index',
+      columns: ['created_at'],
+    },
+    {
+      name: 'requests_duration_ms_index',
+      columns: ['duration_ms'],
+    },
+    {
+      name: 'requests_status_code_index',
+      columns: ['status_code'],
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+    useSoftDeletes: true,
+    useSeeder: {
+      count: 50,
+    },
+    useApi: {
+      uri: 'requests',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  attributes: {
+    method: {
+      fillable: true,
+      validation: {
+        rule: schema.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD']),
+        message: {
+          enum: 'method must be a valid HTTP method',
+          required: 'method is required',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['GET', 'POST', 'PUT', 'DELETE']),
+    },
+
+    path: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'path must be a string',
+          required: 'path is required',
+        },
+      },
+      factory: faker => faker.internet.url(),
+    },
+
+    status_code: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          number: 'status_code must be a number',
+          required: 'status_code is required',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement([200, 201, 400, 401, 403, 404, 500]),
+    },
+
+    duration_ms: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          number: 'duration_ms must be a number',
+          required: 'duration_ms is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 50, max: 1000 }),
+    },
+
+    ip_address: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'ip_address must be a string',
+          required: 'ip_address is required',
+        },
+      },
+      factory: faker => faker.internet.ip(),
+    },
+
+    memory_usage: {
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          number: 'memory_usage must be a number in MB',
+          required: 'memory_usage is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 50, max: 512 }),
+    },
+
+    user_agent: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'user_agent must be a string',
+        },
+      },
+      factory: faker => faker.internet.userAgent(),
+    },
+
+    error_message: {
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+        message: {
+          string: 'error_message must be a string',
+        },
+      },
+      factory: faker => faker.helpers.maybe(() => faker.lorem.sentence(), { probability: 0.2 }),
+    },
+  },
+} as const)

package/dist/models/SenderDomain.ts

@@ -0,0 +1,22 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'SenderDomain',
+  table: 'sender_domains',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'sender-domains', routes: ['index', 'store', 'show', 'update', 'destroy'], middleware: ['auth', 'team'] },
+  },
+  indexes: [{ name: 'sender_domains_domain_unique', columns: ['domain'], unique: true }],
+  attributes: {
+    domain: { required: true, fillable: true, validation: { rule: schema.string().max(253) }, factory: faker => faker.internet.domainName() },
+    status: { required: true, fillable: true, default: 'pending', validation: { rule: schema.enum(['pending', 'verified', 'failed', 'disabled']) }, factory: () => 'pending' },
+    selector: { required: true, fillable: true, default: 'mail', validation: { rule: schema.string().max(63) }, factory: () => 'mail' },
+    dnsRecords: { required: false, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify([]) },
+    verifiedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+    lastCheckedAt: { required: false, fillable: true, validation: { rule: schema.timestamp() }, factory: () => null },
+  },
+} as const)

package/dist/models/Site.ts

@@ -0,0 +1,112 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A public web property served by this app: one host (subdomain of
+ * `config.sites.baseDomain`, plus any verified custom domains via
+ * SiteDomain), one content tree, one theme. A team may own several - a main
+ * site, a microsite, a campaign landing page - each with its own domain.
+ *
+ * The `useApi` surface is the ADMIN surface (auth'd, team-scoped). Public
+ * visitors never read sites through it; the serving layer resolves the site
+ * from the Host header (`@stacksjs/sites`).
+ */
+export default defineModel({
+  name: 'Site',
+  table: 'sites',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    observe: true, // site:updated clears the host-resolution cache
+
+    useSeeder: {
+      count: 2,
+    },
+
+    useApi: {
+      uri: 'sites',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth', 'team'],
+    },
+
+    useSearch: {
+      displayable: ['id', 'name', 'subdomain', 'status'],
+      searchable: ['name', 'subdomain'],
+      sortable: ['name', 'createdAt'],
+      filterable: ['status'],
+    },
+  },
+
+  belongsTo: ['Team'],
+  hasMany: ['SiteDomain'],
+
+  attributes: {
+    name: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(2).max(255),
+        message: {
+          min: 'Site name must have a minimum of 2 characters',
+          max: 'Site name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => `${faker.company.name()} School`,
+    },
+
+    subdomain: {
+      required: true,
+      order: 2,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(2).max(63).matches(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/),
+        message: {
+          matches: 'Subdomain may only contain lowercase letters, numbers and hyphens',
+        },
+      },
+      factory: faker => faker.internet.domainWord(),
+    },
+
+    status: {
+      required: true,
+      order: 3,
+      fillable: true,
+      default: 'active',
+      validation: {
+        rule: schema.enum(['active', 'suspended', 'archived'] as const),
+      },
+      factory: () => 'active',
+    },
+
+    /** Theme tokens, locale, analytics id - render-time knobs, JSON. */
+    settings: {
+      required: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.json(),
+      },
+      factory: () => JSON.stringify({}),
+    },
+
+    timezone: {
+      required: false,
+      order: 5,
+      fillable: true,
+      default: 'America/New_York',
+      validation: {
+        rule: schema.string().max(64),
+      },
+      factory: () => 'America/New_York',
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+})

package/dist/models/SiteDomain.ts

@@ -0,0 +1,74 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A custom domain routed to a Site. Only rows with `verifiedAt` set resolve
+ * traffic - verification proves the school controls the DNS before we serve
+ * their content on it. `isPrimary` names the canonical host: sessions are
+ * host-scoped cookies, so every other host 301s there and portal logins
+ * always land on one origin.
+ */
+export default defineModel({
+  name: 'SiteDomain',
+  table: 'site_domains',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    observe: true, // domain changes clear the host-resolution cache
+
+    useApi: {
+      uri: 'site-domains',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth'],
+    },
+  },
+
+  belongsTo: ['Site'],
+
+  attributes: {
+    domain: {
+      required: true,
+      order: 1,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(4).max(253),
+      },
+      factory: faker => faker.internet.domainName(),
+    },
+
+    isPrimary: {
+      required: false,
+      order: 2,
+      fillable: true,
+      default: false,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: () => false,
+    },
+
+    verifiedAt: {
+      required: false,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => null,
+    },
+
+    sslStatus: {
+      required: false,
+      order: 4,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'issued', 'failed'] as const),
+      },
+      factory: () => 'pending',
+    },
+  },
+})

package/dist/models/SmsOptOut.ts

@@ -0,0 +1,65 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A phone number that texted STOP. Keyed by NUMBER, not user - the reply
+ * comes from a handset, and whoever holds it has spoken for it. Checked by
+ * `notify()`'s sms channel on every non-emergency send; written and cleared
+ * by `handleInboundSms()` (`@stacksjs/sms`).
+ */
+export default defineModel({
+  name: 'SmsOptOut',
+  table: 'sms_opt_outs',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'sms_opt_outs_phone_unique',
+      columns: ['phone'],
+      unique: true,
+    },
+  ],
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  attributes: {
+    /** E.164 where derivable (`+13105550199`). */
+    phone: {
+      required: true,
+      order: 1,
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().min(7).max(20),
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    reason: {
+      required: false,
+      order: 2,
+      fillable: true,
+      default: 'stop-keyword',
+      validation: {
+        rule: schema.string().max(64),
+      },
+      factory: () => 'stop-keyword',
+    },
+
+    optedOutAt: {
+      required: true,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.recent()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+  },
+} as const)