@southwind-ai/database 0.1.2 → 0.2.0

package/index.ts

@@ -1,4 +1,5 @@
 export * from "./src/dialects.js";
+export * from "./src/postgres-module-migrations.js";
 export * from "./src/runner.js";
 export * from "./src/schema/index.js";
 export * from "./src/sql-store.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/database",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
@@ -15,7 +15,7 @@
     "typecheck": "tsc --noEmit --project tsconfig.json"
   },
   "dependencies": {
-    "@southwind-ai/shared": "0.1.2",
+    "@southwind-ai/shared": "0.2.0",
     "drizzle-orm": "^0.45.2"
   },
   "exports": {
@@ -23,5 +23,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "pg": "^8.22.0"
   }
 }

package/src/postgres-module-migrations.ts

@@ -0,0 +1,69 @@
+import type { MigrationBundle } from "@southwind-ai/shared";
+import { PlatformMigrationRunner, type MigrationRunReport } from "./runner.js";
+import {
+  createPostgresStatementExecutor,
+  PostgresMigrationHistoryStore,
+  type QueryableClient,
+} from "./sql-store.js";
+
+const MODULE_MIGRATION_LOCK = "windy.module-migrations.v1";
+
+export interface PostgresTransactionClient extends QueryableClient {
+  release(): void;
+}
+
+export interface PostgresTransactionPool {
+  connect(): Promise<PostgresTransactionClient>;
+}
+
+export interface PostgresMigrationBundleOptions {
+  pool: PostgresTransactionPool;
+  bundles: readonly MigrationBundle[];
+  now?: () => Date;
+}
+
+export async function runPostgresMigrationBundles(
+  options: PostgresMigrationBundleOptions,
+): Promise<MigrationRunReport> {
+  const client = await options.pool.connect();
+  let transactionOpen = false;
+  try {
+    await client.query("begin");
+    transactionOpen = true;
+    await client.query("select pg_advisory_xact_lock(hashtext($1))", [
+      MODULE_MIGRATION_LOCK,
+    ]);
+    const runner = new PlatformMigrationRunner({
+      dialect: "postgresql",
+      store: new PostgresMigrationHistoryStore(client),
+      execute: createPostgresStatementExecutor(client),
+      now: options.now,
+      recordFailures: false,
+    });
+    const report = await runner.runBundles(options.bundles);
+    const failure = report.failed[0];
+    if (failure) {
+      throw new Error(
+        `Module Migration ${failure.id} 执行失败：${failure.error}`,
+      );
+    }
+    await client.query("commit");
+    transactionOpen = false;
+    return report;
+  } catch (error) {
+    if (transactionOpen) await rollbackWithoutMasking(client);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+async function rollbackWithoutMasking(
+  client: PostgresTransactionClient,
+): Promise<void> {
+  try {
+    await client.query("rollback");
+  } catch {
+    // 原始 migration 错误决定启动失败原因，连接释放后由 Pool 负责处置。
+  }
+}

package/src/runner.ts

@@ -17,11 +17,14 @@ export interface MigrationRunnerOptions {
   store: MigrationHistoryStore;
   execute?: (statement: MigrationStatement) => Promise<void>;
   now?: () => Date;
+  recordFailures?: boolean;
 }
 
 export interface MigrationPlanItem {
   id: string;
   module: string;
+  moduleVersion: string;
+  migrationOrder: number;
   description: string;
   direction: "up" | "down";
   checksum: string;
@@ -62,9 +65,15 @@ export class PlatformMigrationRunner {
   ): Promise<MigrationPlanItem[]> {
     const ordered = validateAndOrderBundles(bundles);
     const applied = appliedById(await this.options.store.listApplied());
+    let migrationOrder = 0;
     return ordered.flatMap((bundle) =>
       orderBundleMigrations(bundle).map((migration) =>
-        planItem(migration, applied.get(migration.id)),
+        planItem(
+          migration,
+          bundle.version,
+          migrationOrder++,
+          applied.get(migration.id),
+        ),
       ),
     );
   }
@@ -119,7 +128,7 @@ export class PlatformMigrationRunner {
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         failed.push({ id: item.id, error: message });
-        if (!dryRun) {
+        if (!dryRun && this.options.recordFailures !== false) {
           await this.recordResult(item, stepStartedAt, stepStatements, message);
         }
         break;
@@ -147,6 +156,8 @@ export class PlatformMigrationRunner {
     await this.options.store.record({
       id: item.id,
       module: item.module,
+      moduleVersion: item.moduleVersion,
+      migrationOrder: item.migrationOrder,
       direction: item.direction,
       status: error ? "failed" : "applied",
       checksum: item.checksum,
@@ -164,6 +175,8 @@ function appliedById(entries: readonly MigrationHistoryEntry[]) {
 
 function planItem(
   migration: BundleMigrationDefinition,
+  moduleVersion: string,
+  migrationOrder: number,
   applied: MigrationHistoryEntry | undefined,
 ): MigrationPlanItem {
   if (applied?.module !== undefined && applied.module !== migration.module) {
@@ -182,6 +195,8 @@ function planItem(
   return {
     id: migration.id,
     module: migration.module,
+    moduleVersion,
+    migrationOrder,
     description: migration.description,
     direction: migration.direction,
     checksum: migration.checksum,

package/src/schema/identity.ts

@@ -27,7 +27,14 @@ export const departments = pgTable(
   },
   (table) => [
     uniqueIndex("uk_departments_code").on(table.code),
+    uniqueIndex("uk_departments_single_root")
+      .on(sql`((1))`)
+      .where(sql`${table.parentId} is null and ${table.deletedAt} is null`),
     index("idx_departments_parent").on(table.parentId),
+    check(
+      "departments_parent_not_self",
+      sql`${table.parentId} is null or ${table.parentId} <> ${table.id}`,
+    ),
   ],
 );
 

package/src/schema/index.ts

@@ -25,9 +25,6 @@ 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/src/schema/migration-history.ts

@@ -1,5 +1,6 @@
 import {
   index,
+  integer,
   jsonb,
   pgTable,
   text,
@@ -12,6 +13,8 @@ export const windyMigrationHistory = pgTable(
   {
     id: varchar("id", { length: 160 }).primaryKey(),
     module: varchar("module", { length: 96 }).notNull(),
+    moduleVersion: varchar("module_version", { length: 64 }),
+    migrationOrder: integer("migration_order"),
     direction: varchar("direction", { length: 16 }).notNull(),
     status: varchar("status", { length: 16 }).notNull(),
     checksum: varchar("checksum", { length: 128 }),

package/src/schema/notifications.ts

@@ -1,5 +1,7 @@
 import {
+  boolean,
   index,
+  integer,
   pgTable,
   primaryKey,
   text,
@@ -9,6 +11,10 @@ import {
   varchar,
 } from "drizzle-orm/pg-core";
 import type { TargetRef } from "@southwind-ai/shared";
+import type {
+  ExternalNotificationChannel,
+  NotificationDeliveryStatus,
+} from "@southwind-ai/shared";
 import { auditColumns, idColumn, statusColumn } from "./common.js";
 import { users } from "./identity.js";
 
@@ -22,15 +28,32 @@ export const platformNotifications = pgTable(
     category: varchar("category", { length: 40 }).notNull(),
     status: statusColumn().notNull(),
     publishedAt: timestamp("published_at", { withTimezone: true }).notNull(),
+    scheduledFor: timestamp("scheduled_for", { withTimezone: true }),
     archivedAt: timestamp("archived_at", { withTimezone: true }),
     archivedBy: varchar("archived_by", { length: 64 }),
     target: jsonb("target").$type<TargetRef>(),
     recipientUserId: varchar("recipient_user_id", { length: 64 }),
+    recipientUserIds: jsonb("recipient_user_ids")
+      .$type<string[]>()
+      .notNull()
+      .default([]),
     recipientRoleCodes: jsonb("recipient_role_codes")
       .$type<string[]>()
       .notNull()
       .default([]),
+    recipientDepartmentIds: jsonb("recipient_department_ids")
+      .$type<string[]>()
+      .notNull()
+      .default([]),
+    includeChildDepartments: boolean("include_child_departments")
+      .notNull()
+      .default(false),
+    deliveryChannels: jsonb("delivery_channels")
+      .$type<ExternalNotificationChannel[]>()
+      .notNull()
+      .default([]),
     sourceKey: varchar("source_key", { length: 180 }),
+    revision: integer("revision").notNull().default(1),
     ...auditColumns,
   },
   (table) => [
@@ -42,6 +65,96 @@ export const platformNotifications = pgTable(
   ],
 );
 
+export const notificationPreferences = pgTable("notification_preferences", {
+  userId: varchar("user_id", { length: 64 })
+    .primaryKey()
+    .references(() => users.id, { onDelete: "restrict" }),
+  enabledChannels: jsonb("enabled_channels")
+    .$type<ExternalNotificationChannel[]>()
+    .notNull()
+    .default([]),
+  disabledCategories: jsonb("disabled_categories")
+    .$type<string[]>()
+    .notNull()
+    .default([]),
+  updatedAt: timestamp("updated_at", { withTimezone: true })
+    .notNull()
+    .defaultNow(),
+  updatedBy: varchar("updated_by", { length: 64 }).notNull(),
+});
+
+export const notificationDeliveryOutbox = pgTable(
+  "notification_delivery_outbox",
+  {
+    id: idColumn().primaryKey(),
+    notificationId: varchar("notification_id", { length: 64 })
+      .notNull()
+      .references(() => platformNotifications.id, { onDelete: "restrict" }),
+    userId: varchar("user_id", { length: 64 })
+      .notNull()
+      .references(() => users.id, { onDelete: "restrict" }),
+    channel: varchar("channel", { length: 16 })
+      .$type<ExternalNotificationChannel>()
+      .notNull(),
+    status: varchar("status", { length: 16 })
+      .$type<NotificationDeliveryStatus>()
+      .notNull(),
+    subject: varchar("subject", { length: 120 }).notNull(),
+    content: text("content").notNull(),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    nextAttemptAt: timestamp("next_attempt_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    leaseToken: varchar("lease_token", { length: 64 }),
+    leaseExpiresAt: timestamp("lease_expires_at", { withTimezone: true }),
+    deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+    providerMessageId: varchar("provider_message_id", { length: 180 }),
+    lastErrorCode: varchar("last_error_code", { length: 64 }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    uniqueIndex("uk_notification_delivery_target").on(
+      table.notificationId,
+      table.userId,
+      table.channel,
+    ),
+    index("idx_notification_delivery_claim").on(
+      table.status,
+      table.nextAttemptAt,
+      table.leaseExpiresAt,
+    ),
+    index("idx_notification_delivery_notification").on(table.notificationId),
+  ],
+);
+
+export const notificationRevisions = pgTable(
+  "notification_revisions",
+  {
+    notificationId: varchar("notification_id", { length: 64 })
+      .notNull()
+      .references(() => platformNotifications.id, { onDelete: "restrict" }),
+    revision: integer("revision").notNull(),
+    title: varchar("title", { length: 120 }).notNull(),
+    summary: varchar("summary", { length: 240 }).notNull(),
+    content: text("content").notNull(),
+    category: varchar("category", { length: 40 }).notNull(),
+    editedAt: timestamp("edited_at", { withTimezone: true }).notNull(),
+    editedBy: varchar("edited_by", { length: 64 }).notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.notificationId, table.revision] }),
+    index("idx_notification_revisions_time").on(
+      table.notificationId,
+      table.editedAt,
+    ),
+  ],
+);
+
 export const notificationReads = pgTable(
   "notification_reads",
   {
@@ -58,3 +171,25 @@ export const notificationReads = pgTable(
     index("idx_notification_reads_user").on(table.userId, table.readAt),
   ],
 );
+
+export const notificationFavorites = pgTable(
+  "notification_favorites",
+  {
+    notificationId: varchar("notification_id", { length: 64 })
+      .notNull()
+      .references(() => platformNotifications.id, { onDelete: "restrict" }),
+    userId: varchar("user_id", { length: 64 })
+      .notNull()
+      .references(() => users.id, { onDelete: "restrict" }),
+    favoritedAt: timestamp("favorited_at", { withTimezone: true })
+      .notNull()
+      .defaultNow(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.notificationId, table.userId] }),
+    index("idx_notification_favorites_user").on(
+      table.userId,
+      table.favoritedAt,
+    ),
+  ],
+);

package/src/schema/platform-settings.ts

@@ -19,11 +19,16 @@ import {
 // @windy-module system.settings begin
 import {
   boolean,
+  jsonb as settingsJsonb,
   pgTable as settingsTable,
   text,
   varchar as settingsVarchar,
 } from "drizzle-orm/pg-core";
 import { auditColumns } from "./common.js";
+import type {
+  WatermarkContentField,
+  WatermarkDensity,
+} from "@southwind-ai/shared";
 // @windy-module system.settings end
 
 // @windy-module system.settings begin
@@ -44,6 +49,14 @@ export const platformWatermarkPolicies = settingsTable(
     id: settingsVarchar("id", { length: 64 }).primaryKey(),
     enabled: boolean("enabled").notNull(),
     businessPagesEnabled: boolean("business_pages_enabled").notNull(),
+    density: settingsVarchar("density", { length: 16 })
+      .$type<WatermarkDensity>()
+      .default("medium")
+      .notNull(),
+    contentFields: settingsJsonb("content_fields")
+      .$type<WatermarkContentField[]>()
+      .default(["username", "displayName"])
+      .notNull(),
     customContent: settingsVarchar("custom_content", { length: 80 }).notNull(),
     ...auditColumns,
   },

package/src/sql-store.ts

@@ -15,6 +15,8 @@ export interface QueryableClient {
 interface MigrationHistoryRow {
   id: string;
   module: string;
+  module_version: string | null;
+  migration_order: number | null;
   direction: "up" | "down";
   status: "applied" | "failed";
   checksum: string | null;
@@ -29,7 +31,8 @@ export class PostgresMigrationHistoryStore implements MigrationHistoryStore {
 
   async listApplied(): Promise<MigrationHistoryEntry[]> {
     const result = await this.client.query<MigrationHistoryRow>(
-      `select id, module, direction, status, checksum, statements, error, started_at, finished_at
+      `select id, module, module_version, migration_order, direction, status,
+              checksum, statements, error, started_at, finished_at
        from windy_migration_history
        where status = $1
        order by finished_at asc`,
@@ -42,10 +45,13 @@ export class PostgresMigrationHistoryStore implements MigrationHistoryStore {
   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)
+         (id, module, module_version, migration_order, direction, status,
+          checksum, statements, error, started_at, finished_at)
+       values ($1, $2, $3, $4, $5, $6, $7, $8::jsonb, $9, $10, $11)
        on conflict (id) do update set
          module = excluded.module,
+         module_version = excluded.module_version,
+         migration_order = excluded.migration_order,
          direction = excluded.direction,
          status = excluded.status,
          checksum = excluded.checksum,
@@ -56,6 +62,8 @@ export class PostgresMigrationHistoryStore implements MigrationHistoryStore {
       [
         entry.id,
         entry.module,
+        entry.moduleVersion || null,
+        entry.migrationOrder ?? null,
         entry.direction,
         entry.status,
         entry.checksum || null,
@@ -86,6 +94,8 @@ function mapHistoryRow(row: MigrationHistoryRow): MigrationHistoryEntry {
   return {
     id: row.id,
     module: row.module,
+    moduleVersion: row.module_version || undefined,
+    migrationOrder: row.migration_order ?? undefined,
     direction: row.direction,
     status: row.status,
     startedAt: toIsoString(row.started_at),

package/src/store.ts

@@ -5,6 +5,8 @@ export type MigrationStatus = "applied" | "failed";
 export interface MigrationHistoryEntry {
   id: string;
   module: string;
+  moduleVersion?: string;
+  migrationOrder?: number;
   direction: "up" | "down";
   status: MigrationStatus;
   startedAt: ISODateTime;

package/src/schema/work-orders.ts

@@ -1,23 +0,0 @@
-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),
-  ],
-);