Make schema drift a compile-time error.

// @generated by @metaobjectsdev/codegen-ts — DO NOT EDIT.
// Source metadata: Subscriber (Subscriber)
// Customize via Subscriber.extra.ts in this directory.
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
import { check, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
import { z } from "zod";

export const subscribers = sqliteTable(
  "subscribers",
  {
    id: integer("id").primaryKey({ autoIncrement: true }),
    email: text("email").notNull(),
    name: text("name"),
    status: text("status", {
      enum: ["active", "paused", "cancelled"] as const,
    }).notNull(),
    createdAt: text("created_at").$defaultFn(() => new Date().toISOString()),
  },
  (table) => [
    check(
      "subscribers_status_chk",
      sql`status IN ('active', 'paused', 'cancelled')`,
    ),
  ],
);
export type Subscriber = InferSelectModel<typeof subscribers>;
export type SubscriberInsert = InferInsertModel<typeof subscribers>;
export type SubscriberUpdate = Partial<SubscriberInsert>;
export type SubscriberStatus = "active" | "paused" | "cancelled";
export const SubscriberInsertSchema = z.object({
  email: z.string().min(1).max(320),
  name: z.string().optional(),
  status: z.enum(["active", "paused", "cancelled"]),
  createdAt: z
    .string()
    .optional()
    .transform(() => new Date().toISOString()),
});

export const SubscriberUpdateSchema = z.object({
  email: z.string().min(1).max(320).optional(),
  name: z.string().optional().nullable(),
  status: z.enum(["active", "paused", "cancelled"]).optional(),
});

/** Typed patch shape for Subscriber: every settable field, optional (FR-035 PATCH). A
 * renamed/dropped field is a compile error at every `updateSubscriber` call site. */
export type SubscriberPatch = z.input<typeof SubscriberUpdateSchema>;

/** Insert-shape for import / restore / replication of Subscriber: identical to
 * SubscriberInsertSchema, but the @autoSet timestamp columns are written VERBATIM
 * (no create-time now() stamp) so the caller's original values are preserved. */
export const SubscriberInsertPreservingSchema = z.object({
  email: z.string().min(1).max(320),
  name: z.string().optional(),
  status: z.enum(["active", "paused", "cancelled"]),
  createdAt: z.string().optional(),
});
/**
 * Metadata constants for Subscriber.
 *
 * Use these instead of magic strings so TS catches typos and refactors stay
 * coherent. Each non-dollar-prefixed key is a per-field object carrying
 * name, label, view, optional htmlType/placeholder/helpText, and the
 * RHF-shaped validation rules derived from the field's validator children.
 *
 * Typical usage with the metaobjects React form helper:
 *
 *   import { useEntityForm } from '@metaobjectsdev/react';
 *   const form = useEntityForm(Subscriber, SubscriberInsertSchema);
 *   <input {...form.input.id} />
 */
export const Subscriber = {
  $entity: "Subscriber",
  $table: "subscribers",
  $path: "/subscribers",
  $apiPrefix: "/api",
  id: { name: "id", label: "Id", view: "number", htmlType: "number" },
  email: {
    name: "email",
    label: "Email",
    view: "text",
    htmlType: "text",
    rules: {
      required: "Email is required",
      maxLength: { value: 320, message: "Must be 320 characters or fewer" },
    },
  },
  name: { name: "name", label: "Name", view: "text", htmlType: "text" },
  status: {
    name: "status",
    label: "Status",
    view: "text",
    htmlType: "text",
    rules: { required: "Status is required" },
  },
  createdAt: {
    name: "createdAt",
    label: "Created At",
    view: "date",
    htmlType: "date",
  },
} as const;
import type { FilterAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const SubscriberFilterAllowlist = {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const SubscriberSortAllowlist = {} as const satisfies SortAllowlist;
export type SubscriberFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: SubscriberFilter[];
  and?: SubscriberFilter[];
};

package acme;

import jakarta.validation.constraints.*;

/** GENERATED — wire DTO for Subscriber. Do not hand-edit; regenerated from metadata. */
public record SubscriberDto(
    Long id,
    @NotNull @Size(min = 1, max = 320) String email,
    String name,
    @NotNull SubscriberStatus status,
    java.time.Instant createdAt
) {
    public enum SubscriberStatus { active, paused, cancelled }

    /** Issue #203 @autoSet: a copy with every @autoSet column (onCreate AND onUpdate) stamped to now() on insert (the model value is ignored; a fresh row's updated_at equals its created_at). */
    public static SubscriberDto stampForInsert(SubscriberDto dto) {
        java.time.Instant __nowInstant = java.time.Instant.now();
        return new SubscriberDto(
            dto.id(),
            dto.email(),
            dto.name(),
            dto.status(),
            __nowInstant
        );
    }

    /** Issue #203 @autoSet: a copy with @autoSet onUpdate columns stamped to now(); onCreate columns are preserved (never rewrites created_at — the full-DTO update path). */
    public static SubscriberDto stampForUpdate(SubscriberDto dto) {
        return new SubscriberDto(
            dto.id(),
            dto.email(),
            dto.name(),
            dto.status(),
            dto.createdAt()
        );
    }

    /** Issue #203 @autoSet escape hatch: the DTO written VERBATIM (import/restore/replication). */
    public static SubscriberDto insertPreserving(SubscriberDto dto) { return dto; }
}

package acme

import jakarta.validation.constraints.NotNull
import jakarta.validation.constraints.Size
import java.time.Instant
import kotlin.Long
import kotlin.String

/**
 * GENERATED — do not hand-edit. Regenerated from metadata.
 */
public data class Subscriber(
  public val id: Long? = null,
  @field:NotNull
  @field:Size(min = 1, max = 320)
  public val email: String,
  public val name: String? = null,
  @field:NotNull
  public val status: SubscriberStatus,
  public val createdAt: Instant? = null,
)

// <auto-generated/>
// Generated by MetaObjects entity-generator. Do not edit by hand.
#nullable enable
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Generated;

[Table("subscribers")]
public class Subscriber
{
    public enum SubscriberStatus { active, paused, cancelled }
    [Key]
    [Column("id")]
    public long Id { get; set; }
    [Column("email")]
    [Required(AllowEmptyStrings = true)]
    [MaxLength(320)]
    [MinLength(1)]
    public string Email { get; set; } = default!;
    [Column("name")]
    public string? Name { get; set; }
    [Column("status")]
    public SubscriberStatus Status { get; set; }
    [Column("created_at")]
    public DateTimeOffset? CreatedAt { get; set; }
}

# @generated by metaobjects — DO NOT EDIT.
# Source metadata: Subscriber (acme::Subscriber)
# Customize via Subscriber_extra.py in this directory.

from __future__ import annotations

import datetime
from typing import Literal

from pydantic import BaseModel, Field


class Subscriber(BaseModel):
    id: int | None = None
    email: str = Field(max_length=320)
    name: str | None = None
    status: Literal["active", "paused", "cancelled"]
    createdAt: datetime.datetime | None = None


class SubscriberCreate(BaseModel):
    """GENERATED — CREATE input: auto-gen PK / @mutability readOnly omitted (writeOnce is settable here, once); @default/@autoSet optional; present values validated (FR-036)."""

    email: str = Field(min_length=1, max_length=320)
    name: str | None = None
    status: Literal["active", "paused", "cancelled"]
    createdAt: datetime.datetime | None = None


class SubscriberPatch(BaseModel):
    """GENERATED — PATCH input: all fields optional (PK, @mutability readOnly and writeOnce excluded); present values validated (FR-036)."""

    email: str | None = Field(default=None, min_length=1, max_length=320)
    name: str | None = None
    status: Literal["active", "paused", "cancelled"] | None = None
    createdAt: datetime.datetime | None = None

// @generated by @metaobjectsdev/codegen-ts — DO NOT EDIT.
// Source metadata: Author (Author)
// Customize via Author.extra.ts in this directory.
import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
import { pgTable, uuid, varchar } from "drizzle-orm/pg-core";
import { z } from "zod";

export const authors = pgTable("authors", {
  id: uuid("id").primaryKey().defaultRandom(),
  name: varchar("name", { length: 120 }).notNull(),
  email: varchar("email", { length: 320 }).notNull(),
  bio: varchar("bio", { length: 2000 }),
});
export type Author = InferSelectModel<typeof authors>;
export type AuthorInsert = InferInsertModel<typeof authors>;
export type AuthorUpdate = Partial<AuthorInsert>;
export const AuthorInsertSchema = z.object({
  name: z.string().min(1).max(120),
  email: z.string().min(1).max(320).regex(new RegExp("^(?:[^@]+@[^@]+)$")),
  bio: z.string().max(500).optional(),
});

export const AuthorUpdateSchema = z.object({
  name: z.string().min(1).max(120).optional(),
  email: z
    .string()
    .min(1)
    .max(320)
    .regex(new RegExp("^(?:[^@]+@[^@]+)$"))
    .optional(),
  bio: z.string().max(500).optional().nullable(),
});

/** Typed patch shape for Author: every settable field, optional (FR-035 PATCH). A
 * renamed/dropped field is a compile error at every `updateAuthor` call site. */
export type AuthorPatch = z.input<typeof AuthorUpdateSchema>;
/**
 * Metadata constants for Author.
 *
 * Use these instead of magic strings so TS catches typos and refactors stay
 * coherent. Each non-dollar-prefixed key is a per-field object carrying
 * name, label, view, optional htmlType/placeholder/helpText, and the
 * RHF-shaped validation rules derived from the field's validator children.
 *
 * Typical usage with the metaobjects React form helper:
 *
 *   import { useEntityForm } from '@metaobjectsdev/react';
 *   const form = useEntityForm(Author, AuthorInsertSchema);
 *   <input {...form.input.id} />
 */
export const Author = {
  $entity: "Author",
  $table: "authors",
  $path: "/authors",
  $apiPrefix: "/api",
  id: { name: "id", label: "Id", view: "text", htmlType: "text" },
  name: {
    name: "name",
    label: "Name",
    view: "text",
    htmlType: "text",
    rules: {
      required: "Name is required",
      maxLength: { value: 120, message: "Must be 120 characters or fewer" },
    },
  },
  email: {
    name: "email",
    label: "Email",
    view: "text",
    htmlType: "text",
    rules: {
      pattern: { value: /[^@]+@[^@]+/, message: "Invalid format" },
      required: "Email is required",
      maxLength: { value: 320, message: "Must be 320 characters or fewer" },
    },
  },
  bio: {
    name: "bio",
    label: "Bio",
    view: "text",
    htmlType: "text",
    rules: {
      minLength: { value: 0, message: "Must be at least 0 characters" },
      maxLength: { value: 500, message: "Must be 500 characters or fewer" },
    },
  },
} as const;
import type { FilterAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const AuthorFilterAllowlist = {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const AuthorSortAllowlist = {} as const satisfies SortAllowlist;
export type AuthorFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: AuthorFilter[];
  and?: AuthorFilter[];
};

// @generated by @metaobjectsdev/codegen-ts — DO NOT EDIT.
// Source metadata: Program (Program)
// Customize via Program.extra.ts in this directory.
import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
import {
  type AnyPgColumn,
  bigint,
  check,
  jsonb,
  pgTable,
  text,
  uuid,
  varchar,
} from "drizzle-orm/pg-core";
import { z } from "zod";
import { authors } from "./Author";
import {
  InstructorProfile,
  InstructorProfileInsertSchema,
} from "./InstructorProfile";
import {
  SyllabusSection,
  SyllabusSectionInsertSchema,
} from "./SyllabusSection";

export const programs = pgTable(
  "programs",
  {
    id: uuid("id").primaryKey().defaultRandom(),
    title: varchar("title", { length: 200 }).notNull(),
    status: text("status", {
      enum: ["draft", "published", "archived"] as const,
    }),
    summary: varchar("summary", { length: 2000 }),
    priceCents: bigint("price_cents", { mode: "number" }),
    coverKey: varchar("cover_key", { length: 80 }),
    authorId: uuid("author_id")
      .notNull()
      .references((): AnyPgColumn => authors.id),
    syllabus: jsonb("syllabus").$type<SyllabusSection[]>(),
    instructorProfile: jsonb("instructor_profile").$type<InstructorProfile>(),
  },
  (table) => [
    check(
      "programs_status_chk",
      sql`status IN ('draft', 'published', 'archived')`,
    ),
  ],
);
export type Program = InferSelectModel<typeof programs>;
export type ProgramInsert = InferInsertModel<typeof programs>;
export type ProgramUpdate = Partial<ProgramInsert>;
export type ProgramStatus = "draft" | "published" | "archived";
export const ProgramInsertSchema = z.object({
  title: z.string().min(1).max(200),
  status: z.enum(["draft", "published", "archived"]).optional(),
  summary: z.string().max(2000).optional(),
  priceCents: z.number().int().optional(),
  coverKey: z.string().max(80).optional(),
  authorId: z.string(),
  syllabus: z.array(SyllabusSectionInsertSchema).optional(),
  instructorProfile: InstructorProfileInsertSchema.optional(),
});

export const ProgramUpdateSchema = z.object({
  title: z.string().min(1).max(200).optional(),
  status: z.enum(["draft", "published", "archived"]).optional().nullable(),
  summary: z.string().max(2000).optional().nullable(),
  priceCents: z.number().int().optional().nullable(),
  coverKey: z.string().max(80).optional().nullable(),
  authorId: z.string().optional(),
  syllabus: z.array(SyllabusSectionInsertSchema).optional().nullable(),
  instructorProfile: InstructorProfileInsertSchema.optional().nullable(),
});

/** Typed patch shape for Program: every settable field, optional (FR-035 PATCH). A
 * renamed/dropped field is a compile error at every `updateProgram` call site. */
export type ProgramPatch = z.input<typeof ProgramUpdateSchema>;
/**
 * Metadata constants for Program.
 *
 * Use these instead of magic strings so TS catches typos and refactors stay
 * coherent. Each non-dollar-prefixed key is a per-field object carrying
 * name, label, view, optional htmlType/placeholder/helpText, and the
 * RHF-shaped validation rules derived from the field's validator children.
 *
 * Typical usage with the metaobjects React form helper:
 *
 *   import { useEntityForm } from '@metaobjectsdev/react';
 *   const form = useEntityForm(Program, ProgramInsertSchema);
 *   <input {...form.input.id} />
 */
export const Program = {
  $entity: "Program",
  $table: "programs",
  $path: "/programs",
  $apiPrefix: "/api",
  id: { name: "id", label: "Id", view: "text", htmlType: "text" },
  title: {
    name: "title",
    label: "Title",
    view: "text",
    htmlType: "text",
    rules: {
      required: "Title is required",
      maxLength: { value: 200, message: "Must be 200 characters or fewer" },
    },
  },
  status: { name: "status", label: "Status", view: "text", htmlType: "text" },
  summary: {
    name: "summary",
    label: "Summary",
    view: "textarea",
    rules: {
      maxLength: { value: 2000, message: "Must be 2000 characters or fewer" },
    },
  },
  priceCents: {
    name: "priceCents",
    label: "Price Cents",
    view: "currency",
    currency: "USD",
    locale: "en-US",
  },
  coverKey: {
    name: "coverKey",
    label: "Cover Key",
    view: "image",
    rules: {
      maxLength: { value: 80, message: "Must be 80 characters or fewer" },
    },
  },
  authorId: {
    name: "authorId",
    label: "Author Id",
    view: "text",
    htmlType: "text",
    rules: { required: "Author Id is required" },
  },
  syllabus: {
    name: "syllabus",
    label: "Syllabus",
    view: "text",
    htmlType: "text",
  },
  instructorProfile: {
    name: "instructorProfile",
    label: "Instructor Profile",
    view: "text",
    htmlType: "text",
  },
} as const;
import type { FilterAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const ProgramFilterAllowlist = {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const ProgramSortAllowlist = {} as const satisfies SortAllowlist;
export type ProgramFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: ProgramFilter[];
  and?: ProgramFilter[];
};

// @generated by @metaobjectsdev/codegen-ts — DO NOT EDIT.
// Source metadata: ProgramSummary (ProgramSummary)
import {
  bigint,
  boolean,
  pgView,
  text,
  uuid,
  varchar,
} from "drizzle-orm/pg-core";
import { z } from "zod";

// View declaration — Drizzle uses this for typed SELECT queries.
// The SQL view is created/managed by migrate-ts; .existing() tells Drizzle
// not to attempt DDL for this declaration.
export const programSummaryView = pgView("v_program_summary", {
  id: uuid("id").notNull(),
  title: varchar("title", { length: 200 }).notNull(),
  authorName: text("author_name"),
  lessonCount: bigint("lesson_count", { mode: "number" }),
  completedRevenueCents: bigint("completed_revenue_cents", { mode: "number" }),
  hasCoverArt: boolean("has_cover_art"),
}).existing();
export const ProgramSummarySchema = z.object({
  id: z.string(),
  title: z.string(),
  authorName: z.string().nullable(),
  lessonCount: z.number().int().nullable(),
  completedRevenueCents: z.number().int().nullable(),
  hasCoverArt: z.boolean().nullable(),
});
export type ProgramSummary = z.infer<typeof ProgramSummarySchema>;
export const ProgramSummary = {
  $entity: "ProgramSummary",
  $view: "v_program_summary",
  $path: "/program-summaries",
  $apiPrefix: "/api",
  id: { name: "id", label: "Id", view: "text", dbCol: "id" },
  title: { name: "title", label: "Title", view: "text", dbCol: "title" },
  authorName: {
    name: "authorName",
    label: "Author Name",
    view: "text",
    dbCol: "author_name",
  },
  lessonCount: {
    name: "lessonCount",
    label: "Lesson Count",
    view: "number",
    dbCol: "lesson_count",
  },
  completedRevenueCents: {
    name: "completedRevenueCents",
    label: "Completed Revenue Cents",
    view: "currency",
    dbCol: "completed_revenue_cents",
    currency: "USD",
    locale: "en-US",
  },
  hasCoverArt: {
    name: "hasCoverArt",
    label: "Has Cover Art",
    view: "checkbox",
    dbCol: "has_cover_art",
  },
} as const;
import type { FilterAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const ProgramSummaryFilterAllowlist =
  {} as const satisfies FilterAllowlist;
import type { SortAllowlist } from "@metaobjectsdev/runtime-ts/drizzle-fastify";

export const ProgramSummarySortAllowlist = {} as const satisfies SortAllowlist;
export type ProgramSummaryFilter = {
  limit?: number;
  offset?: number;
  sort?: string;
  or?: ProgramSummaryFilter[];
  and?: ProgramSummaryFilter[];
};