create-windy 0.1.0

package/template/packages/database/src/schema/governed-exports.ts

@@ -0,0 +1,90 @@
+import { sql } from "drizzle-orm";
+import type { LifecycleStatus } from "@windy/shared";
+import {
+  boolean,
+  check,
+  index,
+  jsonb,
+  pgTable,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type { GovernedExportScopeSnapshot } from "./common.js";
+import { durableJobs } from "./durable-jobs.js";
+
+export interface GovernedExportQuerySnapshot {
+  q?: string;
+  status?: LifecycleStatus;
+  includeDeleted: boolean;
+  sort?: Array<{ field: string; order: "asc" | "desc" }>;
+}
+
+export const governedExportRequests = pgTable(
+  "governed_export_requests",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    resourceType: varchar("resource_type", { length: 160 }).notNull(),
+    policyKey: varchar("policy_key", { length: 160 }).notNull(),
+    policyVersion: varchar("policy_version", { length: 40 }).notNull(),
+    fieldKeys: jsonb("field_keys").$type<string[]>().notNull(),
+    requesterId: varchar("requester_id", { length: 64 }).notNull(),
+    requesterName: varchar("requester_name", { length: 160 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 160 }).notNull(),
+    requestFingerprint: varchar("request_fingerprint", {
+      length: 64,
+    }).notNull(),
+    reason: varchar("reason", { length: 500 }).notNull(),
+    scopeSnapshot: jsonb("scope_snapshot")
+      .$type<GovernedExportScopeSnapshot>()
+      .notNull(),
+    scopeHash: varchar("scope_hash", { length: 64 }).notNull(),
+    querySnapshot: jsonb("query_snapshot")
+      .$type<GovernedExportQuerySnapshot>()
+      .notNull(),
+    status: varchar("status", { length: 32 }).notNull(),
+    approvalRequired: boolean("approval_required").notNull(),
+    approvalId: varchar("approval_id", { length: 64 }),
+    durableJobId: varchar("durable_job_id", { length: 64 }).references(
+      () => durableJobs.id,
+      { onDelete: "restrict" },
+    ),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_governed_exports_idempotency").on(
+      table.requesterId,
+      table.resourceType,
+      table.idempotencyKey,
+    ),
+    uniqueIndex("uk_governed_exports_job")
+      .on(table.durableJobId)
+      .where(sql`${table.durableJobId} is not null`),
+    index("idx_governed_exports_owner_created").on(
+      table.requesterId,
+      table.createdAt,
+    ),
+    index("idx_governed_exports_expiry").on(table.status, table.expiresAt),
+    check(
+      "ck_governed_exports_status",
+      sql`${table.status} in ('pending-approval', 'queued', 'running', 'succeeded', 'failed', 'cancelled', 'rejected')`,
+    ),
+    check(
+      "ck_governed_exports_scope_hash",
+      sql`${table.scopeHash} ~ '^[0-9a-f]{64}$'`,
+    ),
+    check(
+      "ck_governed_exports_approval_job_state",
+      sql`(${table.approvalRequired} or ${table.approvalId} is null)
+        and (${table.status} <> 'pending-approval' or (${table.approvalRequired} and ${table.durableJobId} is null))
+        and (${table.status} not in ('running', 'succeeded') or ${table.durableJobId} is not null)
+        and (${table.durableJobId} is null or not ${table.approvalRequired} or ${table.approvalId} is not null)`,
+    ),
+  ],
+);

package/template/packages/database/src/schema/identity.ts

@@ -0,0 +1,169 @@
+import {
+  check,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+import { auditColumns, idColumn, statusColumn } from "./common.js";
+import type { CredentialState } from "@windy/shared";
+
+export const departments = pgTable(
+  "departments",
+  {
+    id: idColumn().primaryKey(),
+    parentId: varchar("parent_id", { length: 64 }),
+    name: varchar("name", { length: 120 }).notNull(),
+    code: varchar("code", { length: 80 }).notNull(),
+    order: integer("order").notNull().default(0),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_departments_code").on(table.code),
+    index("idx_departments_parent").on(table.parentId),
+  ],
+);
+
+export const users = pgTable(
+  "users",
+  {
+    id: idColumn().primaryKey(),
+    username: varchar("username", { length: 80 }).notNull(),
+    displayName: varchar("display_name", { length: 120 }).notNull(),
+    passwordHash: text("password_hash"),
+    credentialState: varchar("credential_state", { length: 40 })
+      .$type<CredentialState>()
+      .notNull()
+      .default("active"),
+    passwordChangedAt: timestamp("password_changed_at", {
+      withTimezone: true,
+    }),
+    email: varchar("email", { length: 160 }),
+    phone: varchar("phone", { length: 32 }),
+    departmentId: varchar("department_id", { length: 64 }),
+    roleIds: jsonb("role_ids").$type<string[]>(),
+    postIds: jsonb("post_ids").$type<string[]>(),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_users_username").on(table.username),
+    uniqueIndex("uk_users_phone").on(table.phone),
+    index("idx_users_department").on(table.departmentId),
+    index("idx_users_status").on(table.status),
+    check(
+      "users_credential_state_check",
+      sql`${table.credentialState} in ('active', 'must-change-password')`,
+    ),
+  ],
+);
+
+export const roles = pgTable(
+  "roles",
+  {
+    id: idColumn().primaryKey(),
+    code: varchar("code", { length: 80 }).notNull(),
+    name: varchar("name", { length: 120 }).notNull(),
+    dataScope: varchar("data_scope", { length: 40 }).notNull(),
+    permissionKeys: jsonb("permission_keys").$type<string[]>(),
+    menuKeys: jsonb("menu_keys").$type<string[]>(),
+    departmentIds: jsonb("department_ids").$type<string[]>(),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_roles_code").on(table.code),
+    index("idx_roles_status").on(table.status),
+  ],
+);
+
+export const userRoles = pgTable(
+  "user_roles",
+  {
+    userId: varchar("user_id", { length: 64 }).notNull(),
+    roleId: varchar("role_id", { length: 64 }).notNull(),
+  },
+  (table) => [primaryKey({ columns: [table.userId, table.roleId] })],
+);
+
+export const rolePermissions = pgTable(
+  "role_permissions",
+  {
+    roleId: varchar("role_id", { length: 64 }).notNull(),
+    permissionKey: varchar("permission_key", { length: 160 }).notNull(),
+  },
+  (table) => [primaryKey({ columns: [table.roleId, table.permissionKey] })],
+);
+
+export const serverSessions = pgTable(
+  "server_sessions",
+  {
+    id: idColumn().primaryKey(),
+    userId: varchar("user_id", { length: 64 }).notNull(),
+    tokenHash: varchar("token_hash", { length: 128 }).notNull(),
+    status: statusColumn().notNull().default("active"),
+    issuedAt: timestamp("issued_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    lastSeenAt: timestamp("last_seen_at", { withTimezone: true }),
+    ip: varchar("ip", { length: 80 }),
+    userAgent: text("user_agent"),
+  },
+  (table) => [
+    uniqueIndex("uk_server_sessions_token_hash").on(table.tokenHash),
+    index("idx_server_sessions_user").on(table.userId),
+    index("idx_server_sessions_status").on(table.status),
+    index("idx_server_sessions_expires").on(table.expiresAt),
+  ],
+);
+
+export const menus = pgTable(
+  "menus",
+  {
+    id: idColumn().primaryKey(),
+    key: varchar("key", { length: 160 }).notNull(),
+    title: varchar("title", { length: 120 }).notNull(),
+    type: varchar("type", { length: 32 }).notNull(),
+    order: integer("order").notNull().default(0),
+    visible: varchar("visible", { length: 32 }).notNull().default("visible"),
+    path: varchar("path", { length: 240 }),
+    component: varchar("component", { length: 240 }),
+    icon: varchar("icon", { length: 80 }),
+    permissionKey: varchar("permission_key", { length: 160 }),
+    featureKey: varchar("feature_key", { length: 160 }),
+    parentKey: varchar("parent_key", { length: 160 }),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_menus_key").on(table.key),
+    index("idx_menus_parent").on(table.parentKey),
+    index("idx_menus_status").on(table.status),
+  ],
+);
+
+export const dictionaries = pgTable(
+  "dictionaries",
+  {
+    id: idColumn().primaryKey(),
+    code: varchar("code", { length: 100 }).notNull(),
+    name: varchar("name", { length: 120 }).notNull(),
+    description: text("description"),
+    items: jsonb("items").$type<Array<Record<string, unknown>>>().notNull(),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_dictionaries_code").on(table.code),
+    index("idx_dictionaries_status").on(table.status),
+  ],
+);

package/template/packages/database/src/schema/index.ts

@@ -0,0 +1,33 @@
+// @windy-module system.bulk-data begin
+export * from "./bulk-data.js";
+// @windy-module system.bulk-data end
+// @windy-module system.scheduler begin
+export * from "./durable-jobs.js";
+// @windy-module system.scheduler end
+// @windy-module system.storage begin
+export * from "./file-storage.js";
+// @windy-module system.storage end
+export * from "./governance.js";
+export type { GovernedExportScopeSnapshot } from "./common.js";
+// @windy-module system.data-governance begin
+export * from "./governed-exports.js";
+// @windy-module system.data-governance end
+export * from "./identity.js";
+// @windy-module system.license begin
+export * from "./license-legacy.js";
+export * from "./license-v1.js";
+// @windy-module system.license end
+export * from "./migration-history.js";
+// @windy-module system.notification begin
+export * from "./notifications.js";
+// @windy-module system.notification end
+export * from "./platform-settings.js";
+// @windy-module system.scheduler begin
+export * from "./scheduler.js";
+// @windy-module system.scheduler end
+// @windy-module work-order begin
+export * from "./work-orders.js";
+// @windy-module work-order end
+// @windy-module system.workflow begin
+export * from "./workflow.js";
+// @windy-module system.workflow end

package/template/packages/database/src/schema/license-legacy.ts

@@ -0,0 +1,93 @@
+import {
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { auditColumns, idColumn, statusColumn } from "./common.js";
+
+/** 原型数据保留区；禁止将这些行解释为正式 V1 License。 */
+export const legacyLicenseProjects = pgTable(
+  "legacy_license_projects",
+  {
+    id: idColumn().primaryKey(),
+    code: varchar("code", { length: 80 }).notNull(),
+    name: varchar("name", { length: 160 }).notNull(),
+    customerName: varchar("customer_name", { length: 160 }).notNull(),
+    contactName: varchar("contact_name", { length: 120 }),
+    notes: text("notes"),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_legacy_license_projects_code").on(table.code),
+    index("idx_legacy_license_projects_status").on(table.status),
+  ],
+);
+
+export const legacyLicenseIssueRecords = pgTable(
+  "legacy_license_issue_records",
+  {
+    id: idColumn().primaryKey(),
+    projectId: varchar("project_id", { length: 64 }).notNull(),
+    operatorId: varchar("operator_id", { length: 64 }).notNull(),
+    subject: varchar("subject", { length: 160 }).notNull(),
+    machineCode: varchar("machine_code", { length: 256 }).notNull(),
+    edition: varchar("edition", { length: 40 }).notNull(),
+    publicKeyId: varchar("public_key_id", { length: 160 }).notNull(),
+    licenseId: varchar("license_id", { length: 64 }).notNull(),
+    limits: jsonb("limits").$type<Record<string, unknown>>().notNull(),
+    modules: jsonb("modules").$type<Record<string, unknown>[]>().notNull(),
+    claims: jsonb("claims").$type<Record<string, unknown>>().notNull(),
+    signature: text("signature").notNull(),
+    signedPayload: text("signed_payload"),
+    algorithm: varchar("algorithm", { length: 40 })
+      .notNull()
+      .default("ED25519"),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+    status: statusColumn().notNull(),
+    issuedAt: timestamp("issued_at", { withTimezone: true }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    revokedBy: varchar("revoked_by", { length: 64 }),
+    revokeReason: text("revoke_reason"),
+  },
+  (table) => [
+    uniqueIndex("uk_legacy_license_issue_license_id").on(table.licenseId),
+    index("idx_legacy_license_issue_project").on(table.projectId),
+    index("idx_legacy_license_issue_operator").on(table.operatorId),
+    index("idx_legacy_license_issue_machine").on(table.machineCode),
+    index("idx_legacy_license_issue_key").on(table.publicKeyId),
+    index("idx_legacy_license_issue_status").on(table.status),
+    index("idx_legacy_license_issue_issued").on(table.issuedAt),
+  ],
+);
+
+export const legacyLicenses = pgTable(
+  "legacy_licenses",
+  {
+    id: idColumn().primaryKey(),
+    licenseKey: varchar("license_key", { length: 160 }).notNull(),
+    subject: varchar("subject", { length: 160 }).notNull(),
+    machineCode: varchar("machine_code", { length: 256 }).notNull(),
+    publicKeyId: varchar("public_key_id", { length: 160 }).notNull(),
+    edition: varchar("edition", { length: 40 }).notNull().default("enterprise"),
+    modules: jsonb("modules").$type<string[]>().notNull().default([]),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+    signedPayload: text("signed_payload"),
+    signature: text("signature").notNull(),
+    status: statusColumn().notNull(),
+    issuedAt: timestamp("issued_at", { withTimezone: true }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    ...auditColumns,
+  },
+  (table) => [
+    index("idx_legacy_licenses_machine").on(table.machineCode),
+    index("idx_legacy_licenses_key").on(table.licenseKey),
+    index("idx_legacy_licenses_status").on(table.status),
+  ],
+);

package/template/packages/database/src/schema/license-v1.ts

@@ -0,0 +1,246 @@
+import type { LicenseV1Claims, LicenseVersionKey } from "@windy/shared";
+import { sql } from "drizzle-orm";
+import {
+  check,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { idColumn, statusColumn } from "./common.js";
+
+const archiveColumns = {
+  status: statusColumn().notNull().default("active"),
+  createdAt: timestamp("created_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  createdBy: varchar("created_by", { length: 64 }).notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  updatedBy: varchar("updated_by", { length: 64 }).notNull(),
+  archivedAt: timestamp("archived_at", { withTimezone: true }),
+  archivedBy: varchar("archived_by", { length: 64 }),
+};
+
+export const licenseCustomers = pgTable(
+  "license_customers",
+  {
+    id: idColumn().primaryKey(),
+    code: varchar("code", { length: 80 }).notNull(),
+    name: varchar("name", { length: 160 }).notNull(),
+    ...archiveColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_license_customers_code").on(table.code),
+    index("idx_license_customers_status").on(table.status),
+  ],
+);
+
+export const licenseProjects = pgTable(
+  "license_projects",
+  {
+    id: idColumn().primaryKey(),
+    customerId: varchar("customer_id", { length: 64 })
+      .notNull()
+      .references(() => licenseCustomers.id, { onDelete: "restrict" }),
+    code: varchar("code", { length: 80 }).notNull(),
+    name: varchar("name", { length: 160 }).notNull(),
+    ...archiveColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_license_projects_customer_code").on(
+      table.customerId,
+      table.code,
+    ),
+    index("idx_license_projects_customer").on(table.customerId),
+    index("idx_license_projects_status").on(table.status),
+  ],
+);
+
+export const licenseVersions = pgTable(
+  "license_versions",
+  {
+    id: idColumn().primaryKey(),
+    projectId: varchar("project_id", { length: 64 })
+      .notNull()
+      .references(() => licenseProjects.id, { onDelete: "restrict" }),
+    key: varchar("key", { length: 80 }).notNull(),
+    name: varchar("name", { length: 120 }).notNull(),
+    description: text("description"),
+    ...archiveColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_license_versions_project_key").on(
+      table.projectId,
+      table.key,
+    ),
+    index("idx_license_versions_project").on(table.projectId),
+    index("idx_license_versions_status").on(table.status),
+  ],
+);
+
+export const licenseContractVersions = pgTable(
+  "license_contract_versions",
+  {
+    id: idColumn().primaryKey(),
+    projectId: varchar("project_id", { length: 64 })
+      .notNull()
+      .references(() => licenseProjects.id, { onDelete: "restrict" }),
+    contractNumber: varchar("contract_number", { length: 120 }).notNull(),
+    version: varchar("version", { length: 40 }).notNull(),
+    licenseVersionId: varchar("license_version_id", { length: 64 })
+      .notNull()
+      .references(() => licenseVersions.id, { onDelete: "restrict" }),
+    ...archiveColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_license_contract_project_number_version").on(
+      table.projectId,
+      table.contractNumber,
+      table.version,
+    ),
+    index("idx_license_contract_project").on(table.projectId),
+    index("idx_license_contract_status").on(table.status),
+  ],
+);
+
+export const licenseNodes = pgTable(
+  "license_nodes",
+  {
+    id: idColumn().primaryKey(),
+    projectId: varchar("project_id", { length: 64 })
+      .notNull()
+      .references(() => licenseProjects.id, { onDelete: "restrict" }),
+    code: varchar("code", { length: 80 }).notNull(),
+    name: varchar("name", { length: 160 }).notNull(),
+    purpose: varchar("purpose", { length: 160 }),
+    machineCode: varchar("machine_code", { length: 256 }).notNull(),
+    ...archiveColumns,
+  },
+  (table) => [
+    uniqueIndex("uk_license_nodes_project_code").on(
+      table.projectId,
+      table.code,
+    ),
+    uniqueIndex("uk_license_nodes_machine").on(table.machineCode),
+    index("idx_license_nodes_project").on(table.projectId),
+    index("idx_license_nodes_status").on(table.status),
+  ],
+);
+
+export const licenses = pgTable(
+  "licenses",
+  {
+    id: idColumn().primaryKey(),
+    formatVersion: integer("format_version").notNull().default(1),
+    productCode: varchar("product_code", { length: 120 }).notNull(),
+    customerId: varchar("customer_id", { length: 64 })
+      .notNull()
+      .references(() => licenseCustomers.id, { onDelete: "restrict" }),
+    projectId: varchar("project_id", { length: 64 })
+      .notNull()
+      .references(() => licenseProjects.id, { onDelete: "restrict" }),
+    contractVersionId: varchar("contract_version_id", { length: 64 })
+      .notNull()
+      .references(() => licenseContractVersions.id, { onDelete: "restrict" }),
+    nodeId: varchar("node_id", { length: 64 })
+      .notNull()
+      .references(() => licenseNodes.id, { onDelete: "restrict" }),
+    machineCode: varchar("machine_code", { length: 256 }).notNull(),
+    licenseVersionKey: varchar("license_version_key", {
+      length: 80,
+    })
+      .$type<LicenseVersionKey>()
+      .notNull(),
+    licenseVersionName: varchar("license_version_name", {
+      length: 120,
+    }).notNull(),
+    claims: jsonb("claims").$type<LicenseV1Claims>().notNull(),
+    signedPayload: text("signed_payload").notNull(),
+    payloadDigest: varchar("payload_digest", { length: 128 }).notNull(),
+    publicKeyId: varchar("public_key_id", { length: 160 }).notNull(),
+    targetSoftwareVersion: varchar("target_software_version", { length: 80 }),
+    algorithm: varchar("algorithm", { length: 40 })
+      .notNull()
+      .default("ED25519"),
+    signature: text("signature").notNull(),
+    issuedAt: timestamp("issued_at", { withTimezone: true }).notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    issuedBy: varchar("issued_by", { length: 64 }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    check("ck_licenses_format_v1", sql`${table.formatVersion} = 1`),
+    check(
+      "ck_licenses_expiry_after_issue",
+      sql`${table.expiresAt} > ${table.issuedAt}`,
+    ),
+    index("idx_license_v1_customer").on(table.customerId),
+    index("idx_license_v1_project").on(table.projectId),
+    index("idx_license_v1_contract").on(table.contractVersionId),
+    index("idx_license_v1_node").on(table.nodeId),
+    index("idx_license_v1_machine_issued").on(
+      table.machineCode,
+      table.issuedAt,
+    ),
+    index("idx_license_v1_key").on(table.publicKeyId),
+    index("idx_license_v1_expires").on(table.expiresAt),
+  ],
+);
+
+export const licenseReplacements = pgTable(
+  "license_replacements",
+  {
+    id: idColumn().primaryKey(),
+    replacedLicenseId: varchar("replaced_license_id", { length: 64 })
+      .notNull()
+      .references(() => licenses.id, { onDelete: "restrict" }),
+    replacementLicenseId: varchar("replacement_license_id", { length: 64 })
+      .notNull()
+      .references(() => licenses.id, { onDelete: "restrict" }),
+    reason: text("reason"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_license_replacements_old").on(table.replacedLicenseId),
+    uniqueIndex("uk_license_replacements_new").on(table.replacementLicenseId),
+    check(
+      "ck_license_replacements_distinct",
+      sql`${table.replacedLicenseId} <> ${table.replacementLicenseId}`,
+    ),
+  ],
+);
+
+export const licenseEvents = pgTable(
+  "license_events",
+  {
+    id: idColumn().primaryKey(),
+    licenseId: varchar("license_id", { length: 64 })
+      .notNull()
+      .references(() => licenses.id, { onDelete: "restrict" }),
+    type: varchar("type", { length: 80 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    payload: jsonb("payload").$type<Record<string, unknown>>().notNull(),
+  },
+  (table) => [
+    index("idx_license_events_license_time").on(
+      table.licenseId,
+      table.occurredAt,
+    ),
+    index("idx_license_events_type_time").on(table.type, table.occurredAt),
+    index("idx_license_events_actor_time").on(table.actorId, table.occurredAt),
+  ],
+);

package/template/packages/database/src/schema/migration-history.ts

@@ -0,0 +1,30 @@
+import {
+  index,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const windyMigrationHistory = pgTable(
+  "windy_migration_history",
+  {
+    id: varchar("id", { length: 160 }).primaryKey(),
+    module: varchar("module", { length: 96 }).notNull(),
+    direction: varchar("direction", { length: 16 }).notNull(),
+    status: varchar("status", { length: 16 }).notNull(),
+    checksum: varchar("checksum", { length: 128 }),
+    statements: jsonb("statements").$type<string[]>(),
+    error: text("error"),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull(),
+    finishedAt: timestamp("finished_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    index("idx_windy_migration_history_module").on(table.module),
+    index("idx_windy_migration_history_status").on(table.status),
+  ],
+);