@southwind-ai/database 0.1.0

package/src/schema/platform-settings.ts

@@ -0,0 +1,69 @@
+// 即使两个可选模块都被裁剪，也要保持该文件可由 schema barrel 导出。
+export {};
+
+// @windy-module system.configuration begin
+import type { ModuleConfigDiffEntry, ModuleConfigValues } from "@southwind-ai/shared";
+import {
+  index,
+  integer,
+  jsonb,
+  pgTable as configTable,
+  timestamp,
+  uniqueIndex,
+  varchar as configVarchar,
+} from "drizzle-orm/pg-core";
+// @windy-module system.configuration end
+// @windy-module system.settings begin
+import {
+  pgTable as settingsTable,
+  text,
+  varchar as settingsVarchar,
+} from "drizzle-orm/pg-core";
+import { auditColumns } from "./common.js";
+// @windy-module system.settings end
+
+// @windy-module system.settings begin
+export const platformBrandingSettings = settingsTable(
+  "platform_branding_settings",
+  {
+    id: settingsVarchar("id", { length: 64 }).primaryKey(),
+    softwareName: settingsVarchar("software_name", { length: 120 }).notNull(),
+    logoUrl: text("logo_url"),
+    description: settingsVarchar("description", { length: 500 }),
+    ...auditColumns,
+  },
+);
+// @windy-module system.settings end
+
+// @windy-module system.configuration begin
+export const moduleConfigVersions = configTable(
+  "module_config_versions",
+  {
+    id: configVarchar("id", { length: 64 }).primaryKey(),
+    moduleKey: configVarchar("module_key", { length: 80 }).notNull(),
+    version: integer("version").notNull(),
+    values: jsonb("values").$type<ModuleConfigValues>().notNull(),
+    diff: jsonb("diff").$type<ModuleConfigDiffEntry[]>().notNull(),
+    applyStatus: configVarchar("apply_status", { length: 24 }).notNull(),
+    applyError: configVarchar("apply_error", { length: 500 }),
+    rollbackOfVersion: integer("rollback_of_version"),
+    reason: configVarchar("reason", { length: 500 }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    createdBy: configVarchar("created_by", { length: 64 }).notNull(),
+    appliedAt: timestamp("applied_at", { withTimezone: true }),
+  },
+  (table) => [
+    uniqueIndex("uk_module_config_versions_module_version").on(
+      table.moduleKey,
+      table.version,
+    ),
+    index("idx_module_config_versions_module_status").on(
+      table.moduleKey,
+      table.applyStatus,
+    ),
+    index("idx_module_config_versions_created_at").on(table.createdAt),
+  ],
+);
+// @windy-module system.configuration end

package/src/schema/scheduler.ts

@@ -0,0 +1,89 @@
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { durableJobs } from "./durable-jobs.js";
+
+export const scheduledTasks = pgTable(
+  "scheduled_tasks",
+  {
+    key: varchar("key", { length: 160 }).primaryKey(),
+    label: varchar("label", { length: 160 }).notNull(),
+    description: text("description"),
+    featureKey: varchar("feature_key", { length: 160 }).notNull(),
+    permissionKey: varchar("permission_key", { length: 160 }).notNull(),
+    intervalSeconds: integer("interval_seconds").notNull(),
+    maxAttempts: integer("max_attempts").notNull().default(1),
+    retryDelaySeconds: integer("retry_delay_seconds").notNull().default(60),
+    enabled: boolean("enabled").notNull().default(true),
+    status: varchar("status", { length: 32 }).notNull().default("active"),
+    nextRunAt: timestamp("next_run_at", { withTimezone: true }).notNull(),
+    lastRunAt: timestamp("last_run_at", { withTimezone: true }),
+    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(),
+  },
+  (table) => [
+    index("idx_scheduled_tasks_due").on(
+      table.status,
+      table.enabled,
+      table.nextRunAt,
+    ),
+    index("idx_scheduled_tasks_feature").on(table.featureKey),
+  ],
+);
+
+export const scheduledTaskRuns = pgTable(
+  "scheduled_task_runs",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    taskKey: varchar("task_key", { length: 160 })
+      .notNull()
+      .references(() => scheduledTasks.key, { onDelete: "restrict" }),
+    trigger: varchar("trigger", { length: 32 }).notNull(),
+    status: varchar("status", { length: 32 }).notNull(),
+    attempt: integer("attempt").notNull().default(1),
+    requestedBy: varchar("requested_by", { length: 64 }).notNull(),
+    retryOfRunId: varchar("retry_of_run_id", { length: 64 }),
+    scheduledFor: timestamp("scheduled_for", { withTimezone: true }).notNull(),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull(),
+    finishedAt: timestamp("finished_at", { withTimezone: true }),
+    nextAttemptAt: timestamp("next_attempt_at", { withTimezone: true }),
+    error: text("error"),
+    result: jsonb("result").$type<Record<string, unknown>>(),
+    durableJobId: varchar("durable_job_id", { length: 64 }).references(
+      () => durableJobs.id,
+      { onDelete: "restrict" },
+    ),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_scheduled_task_runs_single_running")
+      .on(table.taskKey)
+      .where(sql`${table.status} = 'running'`),
+    index("idx_scheduled_task_runs_task_started").on(
+      table.taskKey,
+      table.startedAt,
+    ),
+    index("idx_scheduled_task_runs_retry_due").on(
+      table.status,
+      table.nextAttemptAt,
+    ),
+    index("idx_scheduled_task_runs_durable_job").on(table.durableJobId),
+  ],
+);

package/src/schema/work-orders.ts

@@ -0,0 +1,23 @@
+import { index, pgTable, text, varchar } from "drizzle-orm/pg-core";
+import { auditColumns, idColumn, statusColumn } from "./common.js";
+
+export const workOrders = pgTable(
+  "work_orders",
+  {
+    id: idColumn().primaryKey(),
+    title: varchar("title", { length: 120 }).notNull(),
+    description: text("description").notNull(),
+    priority: varchar("priority", { length: 24 }).notNull(),
+    workflowStatus: varchar("workflow_status", { length: 32 }).notNull(),
+    ownerId: varchar("owner_id", { length: 64 }).notNull(),
+    departmentId: varchar("department_id", { length: 64 }),
+    status: statusColumn().notNull(),
+    ...auditColumns,
+  },
+  (table) => [
+    index("idx_work_orders_owner").on(table.ownerId),
+    index("idx_work_orders_department").on(table.departmentId),
+    index("idx_work_orders_status").on(table.status),
+    index("idx_work_orders_workflow").on(table.workflowStatus),
+  ],
+);

package/src/schema/workflow.ts

@@ -0,0 +1,86 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type { CandidateRole, TargetRef, WorkItem } from "@southwind-ai/shared";
+
+export const workflowWorkItems = pgTable(
+  "workflow_work_items",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    title: varchar("title", { length: 160 }).notNull(),
+    status: varchar("status", { length: 32 }).notNull(),
+    requesterId: varchar("requester_id", { length: 64 }).notNull(),
+    candidateRoles: jsonb("candidate_roles").$type<CandidateRole[]>().notNull(),
+    assigneeId: varchar("assignee_id", { length: 64 }),
+    assigneeName: varchar("assignee_name", { length: 120 }),
+    assigneeRoleCodes: jsonb("assignee_role_codes")
+      .$type<string[]>()
+      .notNull()
+      .default([]),
+    dueAt: timestamp("due_at", { withTimezone: true }).notNull(),
+    target: jsonb("target").$type<TargetRef>().notNull(),
+    createdIdempotencyKey: varchar("created_idempotency_key", {
+      length: 160,
+    }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+    version: integer("version").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_workflow_work_items_create_request").on(
+      table.requesterId,
+      table.createdIdempotencyKey,
+    ),
+    index("idx_workflow_work_items_candidate").using(
+      "gin",
+      table.candidateRoles,
+    ),
+    index("idx_workflow_work_items_assignee").on(
+      table.assigneeId,
+      table.status,
+    ),
+    index("idx_workflow_work_items_due").on(table.status, table.dueAt),
+    check("ck_workflow_work_items_version", sql`${table.version} > 0`),
+  ],
+);
+
+export const workflowTransitions = pgTable(
+  "workflow_transitions",
+  {
+    id: varchar("id", { length: 64 }).primaryKey(),
+    workItemId: varchar("work_item_id", { length: 64 })
+      .notNull()
+      .references(() => workflowWorkItems.id, { onDelete: "restrict" }),
+    command: varchar("command", { length: 32 }).notNull(),
+    beforeStatus: varchar("before_status", { length: 32 }).notNull(),
+    afterStatus: varchar("after_status", { length: 32 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 160 }).notNull(),
+    decision: varchar("decision", { length: 32 }),
+    reason: text("reason"),
+    previousAssigneeId: varchar("previous_assignee_id", { length: 64 }),
+    assigneeId: varchar("assignee_id", { length: 64 }),
+    target: jsonb("target").$type<TargetRef>().notNull(),
+    resultSnapshot: jsonb("result_snapshot").$type<WorkItem>().notNull(),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_workflow_transitions_request").on(
+      table.actorId,
+      table.idempotencyKey,
+    ),
+    index("idx_workflow_transitions_item").on(
+      table.workItemId,
+      table.occurredAt,
+    ),
+  ],
+);

package/src/sql-store.ts

@@ -0,0 +1,101 @@
+import type { MigrationStatement } from "@southwind-ai/shared";
+import type { MigrationHistoryEntry, MigrationHistoryStore } from "./store.js";
+
+export interface QueryResult<Row> {
+  rows: Row[];
+}
+
+export interface QueryableClient {
+  query<Row = Record<string, unknown>>(
+    sql: string,
+    params?: unknown[],
+  ): Promise<QueryResult<Row>>;
+}
+
+interface MigrationHistoryRow {
+  id: string;
+  module: string;
+  direction: "up" | "down";
+  status: "applied" | "failed";
+  checksum: string | null;
+  statements: string[] | null;
+  error: string | null;
+  started_at: Date | string;
+  finished_at: Date | string;
+}
+
+export class PostgresMigrationHistoryStore implements MigrationHistoryStore {
+  constructor(private readonly client: QueryableClient) {}
+
+  async listApplied(): Promise<MigrationHistoryEntry[]> {
+    const result = await this.client.query<MigrationHistoryRow>(
+      `select id, module, direction, status, checksum, statements, error, started_at, finished_at
+       from windy_migration_history
+       where status = $1
+       order by finished_at asc`,
+      ["applied"],
+    );
+
+    return result.rows.map(mapHistoryRow);
+  }
+
+  async record(entry: MigrationHistoryEntry): Promise<void> {
+    await this.client.query(
+      `insert into windy_migration_history
+         (id, module, direction, status, checksum, statements, error, started_at, finished_at)
+       values ($1, $2, $3, $4, $5, $6::jsonb, $7, $8, $9)
+       on conflict (id) do update set
+         module = excluded.module,
+         direction = excluded.direction,
+         status = excluded.status,
+         checksum = excluded.checksum,
+         statements = excluded.statements,
+         error = excluded.error,
+         started_at = excluded.started_at,
+         finished_at = excluded.finished_at`,
+      [
+        entry.id,
+        entry.module,
+        entry.direction,
+        entry.status,
+        entry.checksum || null,
+        JSON.stringify(entry.statements || []),
+        entry.error || null,
+        entry.startedAt,
+        entry.finishedAt,
+      ],
+    );
+  }
+}
+
+export function createPostgresStatementExecutor(client: QueryableClient) {
+  return async (statement: MigrationStatement): Promise<void> => {
+    await client.query(statement.sql, statement.params);
+  };
+}
+
+export function splitDrizzleSqlStatements(sql: string): MigrationStatement[] {
+  return sql
+    .split("--> statement-breakpoint")
+    .map((statement) => statement.trim())
+    .filter(Boolean)
+    .map((statement) => ({ sql: statement }));
+}
+
+function mapHistoryRow(row: MigrationHistoryRow): MigrationHistoryEntry {
+  return {
+    id: row.id,
+    module: row.module,
+    direction: row.direction,
+    status: row.status,
+    startedAt: toIsoString(row.started_at),
+    finishedAt: toIsoString(row.finished_at),
+    checksum: row.checksum || undefined,
+    statements: row.statements || undefined,
+    error: row.error || undefined,
+  };
+}
+
+function toIsoString(value: Date | string): string {
+  return value instanceof Date ? value.toISOString() : value;
+}

package/src/store.ts

@@ -0,0 +1,32 @@
+import type { ISODateTime } from "@southwind-ai/shared";
+
+export type MigrationStatus = "applied" | "failed";
+
+export interface MigrationHistoryEntry {
+  id: string;
+  module: string;
+  direction: "up" | "down";
+  status: MigrationStatus;
+  startedAt: ISODateTime;
+  finishedAt: ISODateTime;
+  checksum?: string;
+  statements?: string[];
+  error?: string;
+}
+
+export interface MigrationHistoryStore {
+  listApplied(): Promise<MigrationHistoryEntry[]>;
+  record(entry: MigrationHistoryEntry): Promise<void>;
+}
+
+export class InMemoryMigrationHistoryStore implements MigrationHistoryStore {
+  private readonly entries: MigrationHistoryEntry[] = [];
+
+  async listApplied(): Promise<MigrationHistoryEntry[]> {
+    return this.entries.filter((entry) => entry.status === "applied");
+  }
+
+  async record(entry: MigrationHistoryEntry): Promise<void> {
+    this.entries.push(entry);
+  }
+}