alepha 0.22.0 → 0.24.0

package/src/api/subscriptions/controllers/SubscriptionController.ts

@@ -1,4 +1,4 @@
-import { $inject, t } from "alepha";
+import { $inject, z } from "alepha";
 import { $secure } from "alepha/security";
 import { $action, NotFoundError, okSchema } from "alepha/server";
 import { cancelSubscriptionSchema } from "../schemas/cancelSubscriptionSchema.ts";
@@ -25,7 +25,7 @@ export class SubscriptionController {
     group: this.group,
     description: "List available subscription plans",
     schema: {
-      response: t.array(planResourceSchema),
+      response: z.array(planResourceSchema),
     },
     handler: async () => {
       const plans = await this.config.getPlans();
@@ -77,8 +77,9 @@ export class SubscriptionController {
       response: subscriptionResourceSchema,
     },
     handler: ({ body, user }) =>
+      // NB: no `skipTrial` — the public subscribe path always honors the
+      // plan's trial. Comped/paid activations go through the service directly.
       this.service.subscribe(user.organization!, body.planId, body.interval, {
-        skipTrial: body.skipTrial,
         metadata: body.metadata,
       }),
   });
@@ -162,7 +163,7 @@ export class SubscriptionController {
     use: [$secure()],
     description: "Get the subscription billing event history",
     schema: {
-      response: t.array(subscriptionEventResourceSchema),
+      response: z.array(subscriptionEventResourceSchema),
     },
     handler: async ({ user }) => {
       const sub = await this.service.getByOrganization(user.organization!);

package/src/api/subscriptions/entities/subscriptionEvents.ts

@@ -1,18 +1,18 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { $entity, db } from "alepha/orm";
 import { subscriptions } from "./subscriptions.ts";
 
 export const subscriptionEvents = $entity({
   name: "subscription_events",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
     createdAt: db.createdAt(),
-    subscriptionId: db.ref(t.uuid(), () => subscriptions.cols.id, {
+    subscriptionId: db.ref(z.uuid(), () => subscriptions.cols.id, {
       onDelete: "cascade",
     }),
     organizationId: db.organization(),
 
-    type: t.enum([
+    type: z.enum([
       "created",
       "trial_started",
       "trial_ended",
@@ -31,18 +31,18 @@ export const subscriptionEvents = $entity({
     ]),
 
     // Context
-    previousStatus: t.optional(t.string()),
-    newStatus: t.optional(t.string()),
-    previousPlanId: t.optional(t.string()),
-    newPlanId: t.optional(t.string()),
-    paymentIntentId: t.optional(t.uuid()),
-    amount: t.optional(t.integer()),
-    currency: t.optional(t.string()),
+    previousStatus: z.string().optional(),
+    newStatus: z.string().optional(),
+    previousPlanId: z.string().optional(),
+    newPlanId: z.string().optional(),
+    paymentIntentId: z.uuid().optional(),
+    amount: z.integer().optional(),
+    currency: z.string().optional(),
 
     // Who / why
-    triggeredBy: t.optional(t.string()),
-    userId: t.optional(t.uuid()),
-    note: t.optional(t.string()),
+    triggeredBy: z.string().optional(),
+    userId: z.uuid().optional(),
+    note: z.string().optional(),
   }),
   indexes: [
     { columns: ["subscriptionId", "createdAt"] },

package/src/api/subscriptions/entities/subscriptions.ts

@@ -1,21 +1,21 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { $entity, db } from "alepha/orm";
 
 export const subscriptions = $entity({
   name: "subscriptions",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
     version: db.version(),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
     organizationId: db.organization(),
 
     // Plan
-    planId: t.string(),
-    interval: t.enum(["monthly", "yearly"]),
+    planId: z.string(),
+    interval: z.enum(["monthly", "yearly"]),
 
     // Status
-    status: t.enum([
+    status: z.enum([
       "trialing",
       "active",
       "past_due",
@@ -25,34 +25,34 @@ export const subscriptions = $entity({
     ]),
 
     // Billing cycle
-    currentPeriodStart: t.datetime(),
-    currentPeriodEnd: t.datetime(),
+    currentPeriodStart: z.datetime(),
+    currentPeriodEnd: z.datetime(),
 
     // Trial
-    trialStart: t.optional(t.datetime()),
-    trialEnd: t.optional(t.datetime()),
+    trialStart: z.datetime().optional(),
+    trialEnd: z.datetime().optional(),
 
     // Cancellation
-    cancelledAt: t.optional(t.datetime()),
-    cancelReason: t.optional(t.string()),
-    cancelAtPeriodEnd: t.boolean({ default: false }),
+    cancelledAt: z.datetime().optional(),
+    cancelReason: z.string().optional(),
+    cancelAtPeriodEnd: z.boolean().default(false),
 
     // Payment tracking
-    lastPaymentIntentId: t.optional(t.uuid()),
-    lastPaymentAt: t.optional(t.datetime()),
-    nextBillingAt: t.optional(t.datetime()),
+    lastPaymentIntentId: z.uuid().optional(),
+    lastPaymentAt: z.datetime().optional(),
+    nextBillingAt: z.datetime().optional(),
 
     // Dunning state
-    dunningStartedAt: t.optional(t.datetime()),
-    dunningAttempt: t.integer({ default: 0 }),
-    dunningNextRetryAt: t.optional(t.datetime()),
+    dunningStartedAt: z.datetime().optional(),
+    dunningAttempt: z.integer().default(0),
+    dunningNextRetryAt: z.datetime().optional(),
 
     // Plan change (pending)
-    pendingPlanId: t.optional(t.string()),
-    pendingInterval: t.optional(t.enum(["monthly", "yearly"])),
+    pendingPlanId: z.string().optional(),
+    pendingInterval: z.enum(["monthly", "yearly"]).optional(),
 
     // Metadata
-    metadata: t.optional(t.record(t.text(), t.any())),
+    metadata: z.record(z.text(), z.any()).optional(),
   }),
   indexes: [
     { columns: ["organizationId"], unique: true },

package/src/api/subscriptions/notifications/SubscriptionNotifications.ts

@@ -1,4 +1,4 @@
-import { t } from "alepha";
+import { z } from "alepha";
 import { $notification } from "alepha/api/notifications";
 
 export class SubscriptionNotifications {
@@ -8,11 +8,11 @@ export class SubscriptionNotifications {
   protected readonly trialEnding = $notification({
     name: "subscription-trial-ending",
     category: "subscriptions",
-    schema: t.object({
-      planName: t.text(),
-      trialEndDate: t.text(),
-      amount: t.text(),
-      interval: t.text(),
+    schema: z.object({
+      planName: z.text(),
+      trialEndDate: z.text(),
+      amount: z.text(),
+      interval: z.text(),
     }),
     email: {
       subject: "Your trial is ending soon",
@@ -28,10 +28,10 @@ export class SubscriptionNotifications {
     name: "subscription-payment-failed",
     category: "subscriptions",
     critical: true,
-    schema: t.object({
-      planName: t.text(),
-      amount: t.text(),
-      retryDate: t.optional(t.text()),
+    schema: z.object({
+      planName: z.text(),
+      amount: z.text(),
+      retryDate: z.text().optional(),
     }),
     email: {
       subject: "Payment failed for your subscription",
@@ -47,7 +47,7 @@ export class SubscriptionNotifications {
     name: "subscription-suspended",
     category: "subscriptions",
     critical: true,
-    schema: t.object({ planName: t.text() }),
+    schema: z.object({ planName: z.text() }),
     email: {
       subject: "Your subscription has been suspended",
       body: (v) =>
@@ -61,10 +61,10 @@ export class SubscriptionNotifications {
   protected readonly subscriptionRenewed = $notification({
     name: "subscription-renewed",
     category: "subscriptions",
-    schema: t.object({
-      planName: t.text(),
-      amount: t.text(),
-      nextBillingDate: t.text(),
+    schema: z.object({
+      planName: z.text(),
+      amount: z.text(),
+      nextBillingDate: z.text(),
     }),
     email: {
       subject: "Payment received — subscription renewed",
@@ -79,10 +79,10 @@ export class SubscriptionNotifications {
   protected readonly planChanged = $notification({
     name: "subscription-plan-changed",
     category: "subscriptions",
-    schema: t.object({
-      oldPlanName: t.text(),
-      newPlanName: t.text(),
-      effectiveDate: t.text(),
+    schema: z.object({
+      oldPlanName: z.text(),
+      newPlanName: z.text(),
+      effectiveDate: z.text(),
     }),
     email: {
       subject: "Your subscription plan has been changed",
@@ -97,9 +97,9 @@ export class SubscriptionNotifications {
   protected readonly cancellationConfirmed = $notification({
     name: "subscription-cancelled",
     category: "subscriptions",
-    schema: t.object({
-      planName: t.text(),
-      accessUntil: t.optional(t.text()),
+    schema: z.object({
+      planName: z.text(),
+      accessUntil: z.text().optional(),
     }),
     email: {
       subject: "Your subscription has been cancelled",

package/src/api/subscriptions/schemas/cancelSubscriptionSchema.ts

@@ -1,8 +1,8 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const cancelSubscriptionSchema = t.object({
-  reason: t.optional(t.string()),
-  immediate: t.optional(t.boolean()),
+export const cancelSubscriptionSchema = z.object({
+  reason: z.string().optional(),
+  immediate: z.boolean().optional(),
 });
 
 export type CancelSubscription = Static<typeof cancelSubscriptionSchema>;

package/src/api/subscriptions/schemas/changePlanSchema.ts

@@ -1,9 +1,9 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const changePlanSchema = t.object({
-  planId: t.string(),
-  interval: t.optional(t.enum(["monthly", "yearly"])),
-  immediate: t.optional(t.boolean()),
+export const changePlanSchema = z.object({
+  planId: z.string(),
+  interval: z.enum(["monthly", "yearly"]).optional(),
+  immediate: z.boolean().optional(),
 });
 
 export type ChangePlan = Static<typeof changePlanSchema>;

package/src/api/subscriptions/schemas/createSubscriptionSchema.ts

@@ -1,11 +1,18 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const createSubscriptionSchema = t.object({
-  planId: t.string(),
-  interval: t.enum(["monthly", "yearly"]),
-  paymentMethodId: t.optional(t.uuid()),
-  skipTrial: t.optional(t.boolean()),
-  metadata: t.optional(t.record(t.text(), t.any())),
+/**
+ * Public body for the self-service subscribe endpoint.
+ *
+ * Deliberately does NOT expose `skipTrial` (or a `paymentMethodId`): skipping
+ * the trial goes straight to a paid `active` subscription with no captured
+ * payment, so it must never be client-controlled. Trusted server-side callers
+ * pass `skipTrial` through the `SubscriptionService.subscribe` options after a
+ * payment is captured — it is not part of the public request.
+ */
+export const createSubscriptionSchema = z.object({
+  planId: z.string(),
+  interval: z.enum(["monthly", "yearly"]),
+  metadata: z.record(z.text(), z.any()).optional(),
 });
 
 export type CreateSubscription = Static<typeof createSubscriptionSchema>;

package/src/api/subscriptions/schemas/entitlementsSchema.ts

@@ -1,9 +1,9 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const entitlementsSchema = t.object({
-  planId: t.string(),
-  planName: t.string(),
-  status: t.enum([
+export const entitlementsSchema = z.object({
+  planId: z.string(),
+  planName: z.string(),
+  status: z.enum([
     "trialing",
     "active",
     "past_due",
@@ -11,11 +11,11 @@ export const entitlementsSchema = t.object({
     "cancelled",
     "expired",
   ]),
-  features: t.array(t.string()),
-  limits: t.record(t.text(), t.integer()),
-  trialEndsAt: t.optional(t.datetime()),
-  periodEndsAt: t.datetime(),
-  cancelledAt: t.optional(t.datetime()),
+  features: z.array(z.string()),
+  limits: z.record(z.text(), z.integer()),
+  trialEndsAt: z.datetime().optional(),
+  periodEndsAt: z.datetime(),
+  cancelledAt: z.datetime().optional(),
 });
 
 export type Entitlements = Static<typeof entitlementsSchema>;

package/src/api/subscriptions/schemas/mrrSchema.ts

@@ -1,13 +1,13 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const mrrSchema = t.object({
-  total: t.integer(),
-  byPlan: t.record(t.text(), t.integer()),
-  growth: t.integer(),
-  newMrr: t.integer(),
-  expansionMrr: t.integer(),
-  contractionMrr: t.integer(),
-  churnMrr: t.integer(),
+export const mrrSchema = z.object({
+  total: z.integer(),
+  byPlan: z.record(z.text(), z.integer()),
+  growth: z.integer(),
+  newMrr: z.integer(),
+  expansionMrr: z.integer(),
+  contractionMrr: z.integer(),
+  churnMrr: z.integer(),
 });
 
 export type MrrData = Static<typeof mrrSchema>;

package/src/api/subscriptions/schemas/planDefinitionSchema.ts

@@ -1,35 +1,35 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const planDefinitionSchema = t.object({
+export const planDefinitionSchema = z.object({
   /**
    * Unique plan identifier (e.g., "free", "starter", "pro", "enterprise").
    */
-  id: t.string({ minLength: 1, maxLength: 50 }),
+  id: z.string().min(1).max(50),
 
   /**
    * Display name (e.g., "Pro Plan").
    */
-  name: t.string(),
+  name: z.string(),
 
   /**
    * Optional description.
    */
-  description: t.optional(t.string()),
+  description: z.string().optional(),
 
   /**
    * Whether this plan is available for new subscriptions.
    */
-  available: t.boolean({ default: true }),
+  available: z.boolean().default(true),
 
   /**
    * Pricing per billing interval.
    * Multiple entries for monthly/yearly.
    */
-  pricing: t.array(
-    t.object({
-      interval: t.enum(["monthly", "yearly"]),
-      amount: t.integer({ minimum: 0 }),
-      currency: t.string({ minLength: 3, maxLength: 3 }),
+  pricing: z.array(
+    z.object({
+      interval: z.enum(["monthly", "yearly"]),
+      amount: z.integer().min(0),
+      currency: z.string().min(3).max(3),
     }),
   ),
 
@@ -37,35 +37,35 @@ export const planDefinitionSchema = t.object({
    * Trial configuration for this plan.
    * Overrides global settings.trialDays if set.
    */
-  trial: t.optional(
-    t.object({
-      days: t.integer({ minimum: 0, maximum: 365 }),
-      requirePaymentMethod: t.boolean({ default: false }),
-    }),
-  ),
+  trial: z
+    .object({
+      days: z.integer().min(0).max(365),
+      requirePaymentMethod: z.boolean().default(false),
+    })
+    .optional(),
 
   /**
    * Feature entitlements. Boolean flags for feature access.
    * Checked via SubscriptionService.can("feature-name").
    */
-  features: t.array(t.string()),
+  features: z.array(z.string()),
 
   /**
    * Usage limits. Numeric caps on resources.
    * Checked via SubscriptionService.limit("resource-name").
    * -1 = unlimited.
    */
-  limits: t.record(t.text(), t.integer()),
+  limits: z.record(z.text(), z.integer()),
 
   /**
    * Sort order for display (lower = first).
    */
-  order: t.integer({ default: 0 }),
+  order: z.integer().default(0),
 
   /**
    * Metadata for app-specific plan data.
    */
-  metadata: t.optional(t.record(t.text(), t.any())),
+  metadata: z.record(z.text(), z.any()).optional(),
 });
 
 export type PlanDefinition = Static<typeof planDefinitionSchema>;

package/src/api/subscriptions/schemas/planResourceSchema.ts

@@ -1,25 +1,25 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const planResourceSchema = t.object({
-  id: t.string(),
-  name: t.string(),
-  description: t.optional(t.string()),
-  pricing: t.array(
-    t.object({
-      interval: t.enum(["monthly", "yearly"]),
-      amount: t.integer(),
-      currency: t.string(),
+export const planResourceSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  pricing: z.array(
+    z.object({
+      interval: z.enum(["monthly", "yearly"]),
+      amount: z.integer(),
+      currency: z.string(),
     }),
   ),
-  features: t.array(t.string()),
-  limits: t.record(t.text(), t.integer()),
-  trial: t.optional(
-    t.object({
-      days: t.integer(),
-      requirePaymentMethod: t.boolean(),
-    }),
-  ),
-  order: t.integer(),
+  features: z.array(z.string()),
+  limits: z.record(z.text(), z.integer()),
+  trial: z
+    .object({
+      days: z.integer(),
+      requirePaymentMethod: z.boolean(),
+    })
+    .optional(),
+  order: z.integer(),
 });
 
 export type PlanResource = Static<typeof planResourceSchema>;

package/src/api/subscriptions/schemas/subscriptionQuerySchema.ts

@@ -1,19 +1,19 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { pageQuerySchema } from "alepha/orm";
 
-export const subscriptionQuerySchema = t.extend(pageQuerySchema, {
-  status: t.optional(
-    t.enum([
+export const subscriptionQuerySchema = pageQuerySchema.extend({
+  status: z
+    .enum([
       "trialing",
       "active",
       "past_due",
       "suspended",
       "cancelled",
       "expired",
-    ]),
-  ),
-  planId: t.optional(t.string()),
-  organizationId: t.optional(t.uuid()),
+    ])
+    .optional(),
+  planId: z.string().optional(),
+  organizationId: z.uuid().optional(),
 });
 
 export type SubscriptionQuery = Static<typeof subscriptionQuerySchema>;

package/src/api/subscriptions/schemas/subscriptionSettingsSchema.ts

@@ -1,32 +1,32 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const subscriptionSettingsSchema = t.object({
+export const subscriptionSettingsSchema = z.object({
   /**
    * Default trial days (overridden per-plan if plan.trial.days is set).
    */
-  trialDays: t.integer({ default: 14, minimum: 0, maximum: 365 }),
+  trialDays: z.integer().min(0).max(365).default(14),
 
   /**
    * Days after payment failure before suspension.
    * During grace period, subscription remains active but flagged.
    */
-  gracePeriodDays: t.integer({ default: 7, minimum: 0, maximum: 30 }),
+  gracePeriodDays: z.integer().min(0).max(30).default(7),
 
   /**
    * Days after first payment failure to retry, relative to the failure date.
    * e.g., [1, 3, 5, 7] means retry on day 1, 3, 5, 7 after failure.
    */
-  dunningSchedule: t.array(t.integer({ minimum: 1 })),
+  dunningSchedule: z.array(z.integer().min(1)),
 
   /**
    * When user cancels, wait until period end (true) or cancel immediately (false).
    */
-  cancelAtPeriodEnd: t.boolean({ default: true }),
+  cancelAtPeriodEnd: z.boolean().default(true),
 
   /**
    * Prorate charges when changing plans mid-cycle.
    */
-  prorateOnChange: t.boolean({ default: true }),
+  prorateOnChange: z.boolean().default(true),
 });
 
 export type SubscriptionSettings = Static<typeof subscriptionSettingsSchema>;

package/src/api/subscriptions/schemas/subscriptionStatsSchema.ts

@@ -1,21 +1,21 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const subscriptionStatsSchema = t.object({
-  total: t.integer(),
-  trialing: t.integer(),
-  active: t.integer(),
-  pastDue: t.integer(),
-  suspended: t.integer(),
-  cancelled: t.integer(),
-  expired: t.integer(),
-  trialConversionRate: t.number(),
-  churnRate: t.number(),
-  byPlan: t.record(
-    t.text(),
-    t.object({
-      active: t.integer(),
-      trialing: t.integer(),
-      total: t.integer(),
+export const subscriptionStatsSchema = z.object({
+  total: z.integer(),
+  trialing: z.integer(),
+  active: z.integer(),
+  pastDue: z.integer(),
+  suspended: z.integer(),
+  cancelled: z.integer(),
+  expired: z.integer(),
+  trialConversionRate: z.number(),
+  churnRate: z.number(),
+  byPlan: z.record(
+    z.text(),
+    z.object({
+      active: z.integer(),
+      trialing: z.integer(),
+      total: z.integer(),
     }),
   ),
 });

package/src/api/subscriptions/services/SubscriptionConfig.ts

@@ -1,4 +1,4 @@
-import { t } from "alepha";
+import { z } from "alepha";
 import { $parameter } from "alepha/api/parameters";
 import { BadRequestError } from "alepha/server";
 import {
@@ -14,7 +14,7 @@ export class SubscriptionConfig {
   protected readonly plans = $parameter({
     name: "subscriptions.plans",
     description: "Subscription plan definitions",
-    schema: t.object({ plans: t.array(planDefinitionSchema) }),
+    schema: z.object({ plans: z.array(planDefinitionSchema) }),
     default: { plans: [] },
   });