@headless-lms/adapter-db 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,79 @@
+# @headless-lms/adapter-db
+
+Drizzle/Postgres persistence adapter. Implements the outbound repository ports from
+`@headless-lms/core` and ships the migrations for the LMS database.
+
+It depends on `@headless-lms/core`, `drizzle-orm` and `pg` — never on the server or
+any other adapter.
+
+## Layout
+
+| Path                  | What lives there                                                           |
+| --------------------- | -------------------------------------------------------------------------- |
+| `src/schema/`         | Drizzle tables, grouped by owning context, barrelled in `index.ts`         |
+| `src/repositories/`   | One `Drizzle*Repository` per context port, plus pg error translation       |
+| `src/client.ts`       | `createDb` — pool + drizzle instance; `Db`, `Tx`, `DbExecutor` types       |
+| `src/unit-of-work.ts` | `DrizzleUnitOfWork` — transaction scope for the core `UnitOfWork` port     |
+| `src/migrate.ts`      | `runMigrations(databaseUrl)` against the packaged `drizzle/` folder        |
+| `drizzle/`            | Generated SQL migrations and snapshots (committed, shipped in the package) |
+
+## Usage
+
+```ts
+import { createDb, runMigrations, DrizzleProgressRepository } from "@headless-lms/adapter-db";
+
+await runMigrations(process.env.DATABASE_URL!);
+
+const db = createDb(process.env.DATABASE_URL!);
+const progress = new DrizzleProgressRepository(db, logger);
+```
+
+Repositories take a `DbExecutor`, so the same class works against the root `db` or a
+transaction handle. `DrizzleUnitOfWork` builds a tx-bound scope, guaranteeing nothing
+escapes the transaction:
+
+```ts
+const uow = new DrizzleUnitOfWork(db, (tx) => ({
+  progress: new DrizzleProgressRepository(tx),
+  outbox: new DrizzleOutboxRepository(tx),
+}));
+
+await uow.run(async ({ progress, outbox }) => {
+  /* ... */
+});
+```
+
+## Error translation
+
+`repositories/pg-errors.ts` turns driver failures into domain errors — unique violations
+become `ConflictError`, everything else becomes a `DbQueryError` carrying the SQL text and
+structured pg fields but never the bind params (they can hold PII).
+
+## Drift checks
+
+`schema/drift.ts` provides compile-time assertions that a table's row type matches its
+domain type from `@headless-lms/core/schemas`. A row field may be wider than the domain's,
+never narrower, missing, or extra. Drift fails `pnpm typecheck` with the offending keys.
+
+## Migration workflow
+
+Push during dev, generate once at the end.
+
+```bash
+pnpm db:push       # apply schema changes straight to the dev database, no files
+pnpm db:generate   # diff against the last committed snapshot → one migration
+pnpm db:migrate    # apply pending migrations
+```
+
+While iterating locally, use `db:push`. When the schema is settled and ready to ship, run
+`db:generate` once — it diffs against the last committed snapshot, so you get a single
+migration containing everything since the previous release.
+
+All three read `DATABASE_URL` from the repo-root `.env`.
+
+## Tests
+
+```bash
+pnpm test        # vitest
+pnpm typecheck
+```

package/dist/client.d.ts

@@ -3,7 +3,7 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 //#region src/client.d.ts
 /** Transaction executor — the same query surface as the root db.
  *  (Promoted from the structure.ts repository's local alias.) */
-type Tx = Parameters<Parameters<NodePgDatabase['transaction']>[0]>[0];
+type Tx = Parameters<Parameters<NodePgDatabase["transaction"]>[0]>[0];
 /** What a Drizzle repository executes against: the root db OR a transaction
  *  handle — tx-bound repo instances are how DrizzleUnitOfWork guarantees no
  *  statement escapes the transaction. */

package/dist/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","names":[],"sources":["../src/client.ts"],"sourcesContent":["// Drizzle client + connection. Owns connection pooling (Drizzle does not).\nimport { drizzle, type NodePgDatabase } from 'drizzle-orm/node-postgres';\nimport pg from 'pg';\n\n/** Transaction executor — the same query surface as the root db.\n *  (Promoted from the structure.ts repository's local alias.) */\nexport type Tx = Parameters<Parameters<NodePgDatabase['transaction']>[0]>[0];\n\n/** What a Drizzle repository executes against: the root db OR a transaction\n *  handle — tx-bound repo instances are how DrizzleUnitOfWork guarantees no\n *  statement escapes the transaction. */\nexport type DbExecutor = NodePgDatabase | Tx;\n\n// Centralized schema — re-exported so the db adapter is the single source for tables.\nexport * as schema from './schema/index.js';\n\nexport type Db = ReturnType<typeof createDb>;\n\nexport function createDb(connectionString: string) {\n  const pool = new pg.Pool({ connectionString });\n  return drizzle(pool);\n}\n"],"mappings":";;;;AAkBA,SAAgB,SAAS,kBAA0B;CAEjD,OAAO,QAAQ,IADE,GAAG,KAAK,EAAE,iBAAiB,CAC1B,CAAC;AACrB"}
+{"version":3,"file":"client.js","names":[],"sources":["../src/client.ts"],"sourcesContent":["// Drizzle client + connection. Owns connection pooling (Drizzle does not).\nimport { drizzle, type NodePgDatabase } from \"drizzle-orm/node-postgres\";\nimport pg from \"pg\";\n\n/** Transaction executor — the same query surface as the root db.\n *  (Promoted from the structure.ts repository's local alias.) */\nexport type Tx = Parameters<Parameters<NodePgDatabase[\"transaction\"]>[0]>[0];\n\n/** What a Drizzle repository executes against: the root db OR a transaction\n *  handle — tx-bound repo instances are how DrizzleUnitOfWork guarantees no\n *  statement escapes the transaction. */\nexport type DbExecutor = NodePgDatabase | Tx;\n\n// Centralized schema — re-exported so the db adapter is the single source for tables.\nexport * as schema from \"./schema/index.js\";\n\nexport type Db = ReturnType<typeof createDb>;\n\nexport function createDb(connectionString: string) {\n  const pool = new pg.Pool({ connectionString });\n  return drizzle(pool);\n}\n"],"mappings":";;;;AAkBA,SAAgB,SAAS,kBAA0B;CAEjD,OAAO,QAAQ,IADE,GAAG,KAAK,EAAE,iBAAiB,CAC1B,CAAC;AACrB"}

package/dist/index.d.ts

@@ -6,17 +6,19 @@ import { DrizzleAssetsRepository } from "./repositories/assets.js";
 import { DrizzleAutomationRunsRepository, DrizzleAutomationsRepository } from "./repositories/automations.js";
 import { DrizzleContentRepository } from "./repositories/content.js";
 import { DrizzleCredentialStore, decryptSecret, encryptSecret } from "./repositories/credentials.js";
-import { DrizzleDashboardRepository } from "./repositories/dashboard.js";
 import { DrizzleDiscussionRepository } from "./repositories/discussion.js";
+import { DrizzlePostRepository } from "./repositories/posts.js";
+import { DrizzleChatRepository } from "./repositories/chats.js";
 import { DrizzleEntitlementsRepository } from "./repositories/entitlements.js";
 import { DrizzleIdentityRepository } from "./repositories/identity.js";
 import { DrizzleConnectionsRepository } from "./repositories/integrations.js";
-import { DrizzleLearnRepository } from "./repositories/learn.js";
+import { DrizzleMemberRepository } from "./repositories/member.js";
 import { DrizzleMembersRepository } from "./repositories/members.js";
-import { orgUserProfileColumns } from "./repositories/org-user-profile.js";
+import { DrizzleNotificationsRepository } from "./repositories/notifications.js";
+import { authorProfileColumns, orgUserProfileColumns, studentFirstName, studentLastName, studentProfileColumns } from "./repositories/org-user-profile.js";
 import { DrizzleOrganizationsRepository } from "./repositories/organizations.js";
 import { DrizzleOutboxAppender, DrizzleOutboxStore, OUTBOX_MAX_ATTEMPTS } from "./repositories/outbox.js";
 import { DrizzleProgressRepository } from "./repositories/progress.js";
 import { DrizzleSettingsRepository, deepMerge } from "./repositories/settings.js";
-import { DrizzleStudentsRepository } from "./repositories/students.js";
-export { type Db, DrizzleAssetsRepository, DrizzleAutomationRunsRepository, DrizzleAutomationsRepository, DrizzleConnectionsRepository, DrizzleContentRepository, DrizzleCredentialStore, DrizzleDashboardRepository, DrizzleDiscussionRepository, DrizzleEntitlementsRepository, DrizzleIdentityRepository, DrizzleLearnRepository, DrizzleMembersRepository, DrizzleOrganizationsRepository, DrizzleOutboxAppender, DrizzleOutboxStore, DrizzleProgressRepository, DrizzleSettingsRepository, DrizzleStudentsRepository, DrizzleUnitOfWork, OUTBOX_MAX_ATTEMPTS, createDb, decryptSecret, deepMerge, encryptSecret, migrationsFolder, orgUserProfileColumns, runMigrations, index_d_exports as schema };
+import { DrizzleAdminRepository } from "./repositories/admin.js";
+export { type Db, DrizzleAdminRepository, DrizzleAssetsRepository, DrizzleAutomationRunsRepository, DrizzleAutomationsRepository, DrizzleChatRepository, DrizzleConnectionsRepository, DrizzleContentRepository, DrizzleCredentialStore, DrizzleDiscussionRepository, DrizzleEntitlementsRepository, DrizzleIdentityRepository, DrizzleMemberRepository, DrizzleMembersRepository, DrizzleNotificationsRepository, DrizzleOrganizationsRepository, DrizzleOutboxAppender, DrizzleOutboxStore, DrizzlePostRepository, DrizzleProgressRepository, DrizzleSettingsRepository, DrizzleUnitOfWork, OUTBOX_MAX_ATTEMPTS, authorProfileColumns, createDb, decryptSecret, deepMerge, encryptSecret, migrationsFolder, orgUserProfileColumns, runMigrations, index_d_exports as schema, studentFirstName, studentLastName, studentProfileColumns };

package/dist/index.js

@@ -4,19 +4,21 @@ import { DrizzleUnitOfWork } from "./unit-of-work.js";
 import { migrationsFolder, runMigrations } from "./migrate.js";
 import { DrizzleAssetsRepository } from "./repositories/assets.js";
 import { DrizzleAutomationRunsRepository, DrizzleAutomationsRepository } from "./repositories/automations.js";
+import { DrizzleSettingsRepository, deepMerge } from "./repositories/settings.js";
 import { DrizzleContentRepository } from "./repositories/content.js";
 import { DrizzleCredentialStore, decryptSecret, encryptSecret } from "./repositories/credentials.js";
-import { DrizzleDashboardRepository } from "./repositories/dashboard.js";
-import { orgUserProfileColumns } from "./repositories/org-user-profile.js";
+import { authorProfileColumns, orgUserProfileColumns, studentFirstName, studentLastName, studentProfileColumns } from "./repositories/org-user-profile.js";
 import { DrizzleDiscussionRepository } from "./repositories/discussion.js";
+import { DrizzlePostRepository } from "./repositories/posts.js";
+import { DrizzleChatRepository } from "./repositories/chats.js";
 import { DrizzleEntitlementsRepository } from "./repositories/entitlements.js";
 import { DrizzleIdentityRepository } from "./repositories/identity.js";
 import { DrizzleConnectionsRepository } from "./repositories/integrations.js";
-import { DrizzleLearnRepository } from "./repositories/learn.js";
+import { DrizzleMemberRepository } from "./repositories/member.js";
 import { DrizzleMembersRepository } from "./repositories/members.js";
+import { DrizzleNotificationsRepository } from "./repositories/notifications.js";
 import { DrizzleOrganizationsRepository } from "./repositories/organizations.js";
 import { DrizzleOutboxAppender, DrizzleOutboxStore, OUTBOX_MAX_ATTEMPTS } from "./repositories/outbox.js";
 import { DrizzleProgressRepository } from "./repositories/progress.js";
-import { DrizzleSettingsRepository, deepMerge } from "./repositories/settings.js";
-import { DrizzleStudentsRepository } from "./repositories/students.js";
-export { DrizzleAssetsRepository, DrizzleAutomationRunsRepository, DrizzleAutomationsRepository, DrizzleConnectionsRepository, DrizzleContentRepository, DrizzleCredentialStore, DrizzleDashboardRepository, DrizzleDiscussionRepository, DrizzleEntitlementsRepository, DrizzleIdentityRepository, DrizzleLearnRepository, DrizzleMembersRepository, DrizzleOrganizationsRepository, DrizzleOutboxAppender, DrizzleOutboxStore, DrizzleProgressRepository, DrizzleSettingsRepository, DrizzleStudentsRepository, DrizzleUnitOfWork, OUTBOX_MAX_ATTEMPTS, createDb, decryptSecret, deepMerge, encryptSecret, migrationsFolder, orgUserProfileColumns, runMigrations, schema_exports as schema };
+import { DrizzleAdminRepository } from "./repositories/admin.js";
+export { DrizzleAdminRepository, DrizzleAssetsRepository, DrizzleAutomationRunsRepository, DrizzleAutomationsRepository, DrizzleChatRepository, DrizzleConnectionsRepository, DrizzleContentRepository, DrizzleCredentialStore, DrizzleDiscussionRepository, DrizzleEntitlementsRepository, DrizzleIdentityRepository, DrizzleMemberRepository, DrizzleMembersRepository, DrizzleNotificationsRepository, DrizzleOrganizationsRepository, DrizzleOutboxAppender, DrizzleOutboxStore, DrizzlePostRepository, DrizzleProgressRepository, DrizzleSettingsRepository, DrizzleUnitOfWork, OUTBOX_MAX_ATTEMPTS, authorProfileColumns, createDb, decryptSecret, deepMerge, encryptSecret, migrationsFolder, orgUserProfileColumns, runMigrations, schema_exports as schema, studentFirstName, studentLastName, studentProfileColumns };

package/dist/migrate.js.map

@@ -1 +1 @@
-{"version":3,"file":"migrate.js","names":[],"sources":["../src/migrate.ts"],"sourcesContent":["// Runs the drizzle migrations shipped inside this package against the\n// installation's database. Fails loudly and legibly — this is the first\n// command every new installation runs.\nimport { fileURLToPath } from 'node:url';\nimport pg from 'pg';\nimport { drizzle } from 'drizzle-orm/node-postgres';\nimport { migrate } from 'drizzle-orm/node-postgres/migrator';\n\n/** drizzle/ sits at the package root: ../drizzle from src/ AND dist/. */\nexport function migrationsFolder(): string {\n  return fileURLToPath(new URL('../drizzle/', import.meta.url));\n}\n\nexport async function runMigrations(databaseUrl: string): Promise<void> {\n  if (!databaseUrl) {\n    throw new Error(\n      'DATABASE_URL is not set. Put it in your .env (e.g. postgres://postgres:postgres@localhost:8005/headless_lms) and re-run.',\n    );\n  }\n  const pool = new pg.Pool({ connectionString: databaseUrl, max: 1 });\n  try {\n    await migrate(drizzle(pool), { migrationsFolder: migrationsFolder() });\n  } catch (err) {\n    throw new Error(\n      `Migration failed against ${databaseUrl.replace(/\\/\\/.*@/, '//***@')}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err },\n    );\n  } finally {\n    await pool.end();\n  }\n}\n"],"mappings":";;;;;;AASA,SAAgB,mBAA2B;CACzC,OAAO,cAAc,IAAI,IAAI,eAAe,OAAO,KAAK,GAAG,CAAC;AAC9D;AAEA,eAAsB,cAAc,aAAoC;CACtE,IAAI,CAAC,aACH,MAAM,IAAI,MACR,0HACF;CAEF,MAAM,OAAO,IAAI,GAAG,KAAK;EAAE,kBAAkB;EAAa,KAAK;CAAE,CAAC;CAClE,IAAI;EACF,MAAM,QAAQ,QAAQ,IAAI,GAAG,EAAE,kBAAkB,iBAAiB,EAAE,CAAC;CACvE,SAAS,KAAK;EACZ,MAAM,IAAI,MACR,4BAA4B,YAAY,QAAQ,WAAW,QAAQ,EAAE,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,KACxH,EAAE,OAAO,IAAI,CACf;CACF,UAAU;EACR,MAAM,KAAK,IAAI;CACjB;AACF"}
+{"version":3,"file":"migrate.js","names":[],"sources":["../src/migrate.ts"],"sourcesContent":["// Runs the drizzle migrations shipped inside this package against the\n// installation's database. Fails loudly and legibly — this is the first\n// command every new installation runs.\nimport { fileURLToPath } from \"node:url\";\nimport pg from \"pg\";\nimport { drizzle } from \"drizzle-orm/node-postgres\";\nimport { migrate } from \"drizzle-orm/node-postgres/migrator\";\n\n/** drizzle/ sits at the package root: ../drizzle from src/ AND dist/. */\nexport function migrationsFolder(): string {\n  return fileURLToPath(new URL(\"../drizzle/\", import.meta.url));\n}\n\nexport async function runMigrations(databaseUrl: string): Promise<void> {\n  if (!databaseUrl) {\n    throw new Error(\n      \"DATABASE_URL is not set. Put it in your .env (e.g. postgres://postgres:postgres@localhost:8005/headless_lms) and re-run.\",\n    );\n  }\n  const pool = new pg.Pool({ connectionString: databaseUrl, max: 1 });\n  try {\n    await migrate(drizzle(pool), { migrationsFolder: migrationsFolder() });\n  } catch (err) {\n    throw new Error(\n      `Migration failed against ${databaseUrl.replace(/\\/\\/.*@/, \"//***@\")}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err },\n    );\n  } finally {\n    await pool.end();\n  }\n}\n"],"mappings":";;;;;;AASA,SAAgB,mBAA2B;CACzC,OAAO,cAAc,IAAI,IAAI,eAAe,OAAO,KAAK,GAAG,CAAC;AAC9D;AAEA,eAAsB,cAAc,aAAoC;CACtE,IAAI,CAAC,aACH,MAAM,IAAI,MACR,0HACF;CAEF,MAAM,OAAO,IAAI,GAAG,KAAK;EAAE,kBAAkB;EAAa,KAAK;CAAE,CAAC;CAClE,IAAI;EACF,MAAM,QAAQ,QAAQ,IAAI,GAAG,EAAE,kBAAkB,iBAAiB,EAAE,CAAC;CACvE,SAAS,KAAK;EACZ,MAAM,IAAI,MACR,4BAA4B,YAAY,QAAQ,WAAW,QAAQ,EAAE,IAAI,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,KACxH,EAAE,OAAO,IAAI,CACf;CACF,UAAU;EACR,MAAM,KAAK,IAAI;CACjB;AACF"}

package/dist/repositories/admin.d.ts

@@ -0,0 +1,23 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { Logger } from "@headless-lms/core/shared/ports";
+import { AdminReportRepository, CommunityAnalytics, CommunityMember, CommunityMembersQuery, CourseAnalytics, CourseEnrollmentPoint, EnrollmentPoint, OverviewStats, Page, Student, StudentAnalytics, StudentsQuery } from "@headless-lms/core/reporting/admin";
+//#region src/repositories/admin.d.ts
+declare class DrizzleAdminRepository implements AdminReportRepository {
+  private readonly db;
+  private readonly logger;
+  constructor(db: NodePgDatabase, logger?: Logger);
+  overview(orgId: string): Promise<OverviewStats>;
+  enrollments(orgId: string, days: number): Promise<EnrollmentPoint[]>;
+  private courseExists;
+  courseAnalytics(orgId: string, courseId: string): Promise<CourseAnalytics | null>;
+  courseEnrollments(orgId: string, courseId: string, days: number): Promise<CourseEnrollmentPoint[] | null>;
+  listStudents(orgId: string, query: StudentsQuery): Promise<Page<Student>>;
+  getStudent(orgId: string, id: string): Promise<Student | null>;
+  studentAnalytics(orgId: string, id: string): Promise<StudentAnalytics | null>;
+  private resolveOrder;
+  communityAnalytics(orgId: string, communityId: string): Promise<CommunityAnalytics | null>;
+  communityMembers(orgId: string, communityId: string, query: CommunityMembersQuery): Promise<Page<CommunityMember> | null>;
+}
+//#endregion
+export { DrizzleAdminRepository };
+//# sourceMappingURL=admin.d.ts.map

package/dist/repositories/admin.js

@@ -0,0 +1,393 @@
+import { communities, courses, spaces } from "../schema/content.js";
+import { commentFlags, comments, messageFlags, messages, postFlags, posts } from "../schema/discussion.js";
+import { users } from "../schema/identity.js";
+import { orgUsers } from "../schema/organizations.js";
+import { contentAccess, entitlements } from "../schema/entitlements.js";
+import "../schema/index.js";
+import { translateDbErrors } from "./pg-errors.js";
+import { user } from "../schema/better-auth.js";
+import { orgUserProfileColumns, studentFirstName, studentLastName, studentProfileColumns } from "./org-user-profile.js";
+import { grantExpired, grantOpens } from "./grant-covers.js";
+import { and, asc, desc, eq, exists, ilike, inArray, or, sql } from "drizzle-orm";
+import { union } from "drizzle-orm/pg-core";
+import { noopLogger } from "@headless-lms/core/shared/logger";
+import { STUDENT_ROLE } from "@headless-lms/core/organizations";
+//#region src/repositories/admin.ts
+const entitlementCountExpr = sql`count(${entitlements.id})`;
+const avgProgressExpr = sql`0`;
+const lastActiveExpr = sql`(
+  select max(pr.updated_at) from progress_records pr
+  where pr.org_id = ${orgUsers.orgId} and pr.org_user_id = ${orgUsers.id}
+)`;
+function toStudent(row) {
+	return {
+		id: row.id,
+		email: row.email,
+		image: row.image ?? null,
+		firstName: row.firstName,
+		lastName: row.lastName,
+		status: row.status,
+		entitlementCount: Number(row.entitlementCount),
+		avgProgress: Number(row.avgProgress),
+		joinedAt: row.createdAt.toISOString(),
+		lastActiveAt: row.lastActiveAt ? new Date(row.lastActiveAt).toISOString() : null
+	};
+}
+var DrizzleAdminRepository = class {
+	db;
+	logger;
+	constructor(db, logger = noopLogger) {
+		this.db = db;
+		this.logger = logger;
+	}
+	async overview(orgId) {
+		const [courseCounts] = await this.db.select({
+			published: sql`count(*) filter (where ${courses.status} = 'published')`,
+			draft: sql`count(*) filter (where ${courses.status} = 'draft')`
+		}).from(courses).where(eq(courses.orgId, orgId));
+		const [entitlementCounts] = await this.db.select({
+			activeStudents: sql`count(distinct ${contentAccess.orgUserId})`,
+			expiringSoon: sql`count(distinct ${contentAccess.entitlementId}) filter (where ${grantExpired(contentAccess.expiresAt, sql`now() + interval '14 days'`)})`
+		}).from(contentAccess).where(eq(contentAccess.orgId, orgId));
+		return {
+			publishedCourses: Number(courseCounts?.published ?? 0),
+			draftCourses: Number(courseCounts?.draft ?? 0),
+			activeStudents: Number(entitlementCounts?.activeStudents ?? 0),
+			expiringSoon: Number(entitlementCounts?.expiringSoon ?? 0)
+		};
+	}
+	async enrollments(orgId, days) {
+		return (await this.db.execute(sql`
+      select
+        to_char(d.day, 'YYYY-MM-DD') as date,
+        count(${entitlements.id})::int as count
+      from generate_series(
+        (now() at time zone 'utc')::date - (${days} - 1),
+        (now() at time zone 'utc')::date,
+        interval '1 day'
+      ) as d(day)
+      left join ${entitlements}
+        on ${entitlements.orgId} = ${orgId}
+        and (${entitlements.grantedAt} at time zone 'utc')::date = d.day::date
+      group by d.day
+      order by d.day
+    `)).rows.map((r) => ({
+			date: r.date,
+			count: Number(r.count)
+		}));
+	}
+	async courseExists(orgId, courseId) {
+		const [row] = await this.db.select({ id: courses.id }).from(courses).where(and(eq(courses.orgId, orgId), eq(courses.id, courseId)));
+		return row !== void 0;
+	}
+	async courseAnalytics(orgId, courseId) {
+		if (!await this.courseExists(orgId, courseId)) return null;
+		const cohort = sql`
+      select distinct org_user_id from content_access
+      where org_id = ${orgId}
+        and content_id = ${courseId}
+    `;
+		const publishedActivities = sql`
+      select a.id, a.settings, a.seq, a.module_id
+      from activities a
+      where a.org_id = ${orgId}
+        and a.course_id = ${courseId}
+        and coalesce((a.settings ->> 'published')::boolean, true)
+    `;
+		const summary = (await this.db.execute(sql`
+      with cohort as (${cohort}),
+      acts as (${publishedActivities}),
+      per_learner as (
+        select c.org_user_id,
+          count(pr.id) filter (where pr.completed_at is not null) as done
+        from cohort c
+        left join progress_records pr
+          on pr.org_id = ${orgId}
+          and pr.org_user_id = c.org_user_id
+          and pr.target_type = 'activity'
+          and pr.target_id in (select id from acts)
+        group by c.org_user_id
+      )
+      select
+        (select count(*) from cohort)::int as enrolled,
+        (
+          select count(distinct pr.org_user_id) from progress_records pr
+          where pr.org_id = ${orgId}
+            and pr.org_user_id in (select org_user_id from cohort)
+            and (
+              (pr.target_type = 'activity' and pr.target_id in (select id from acts))
+              or (pr.target_type = 'course' and pr.target_id = ${courseId})
+            )
+        )::int as started,
+        (
+          select count(*) from progress_records pr
+          where pr.org_id = ${orgId}
+            and pr.org_user_id in (select org_user_id from cohort)
+            and pr.target_type = 'course'
+            and pr.target_id = ${courseId}
+            and pr.completed_at is not null
+        )::int as completed,
+        coalesce((
+          select round(avg(least(done::numeric / nullif((select count(*) from acts), 0), 1) * 100))
+          from per_learner
+        ), 0)::int as avg_progress
+    `)).rows[0];
+		const activities = (await this.db.execute(sql`
+      with cohort as (${cohort})
+      select
+        a.id,
+        coalesce(a.settings ->> 'title', '') as title,
+        m.id as module_id,
+        m.title as module_title,
+        count(pr.id)::int as started,
+        count(pr.id) filter (where pr.completed_at is not null)::int as completed
+      from activities a
+      join modules m on m.org_id = a.org_id and m.id = a.module_id
+      left join progress_records pr
+        on pr.org_id = ${orgId}
+        and pr.target_type = 'activity'
+        and pr.target_id = a.id
+        and pr.org_user_id in (select org_user_id from cohort)
+      where a.org_id = ${orgId}
+        and a.course_id = ${courseId}
+        and coalesce((a.settings ->> 'published')::boolean, true)
+      group by a.id, a.settings, m.id, m.title, m.seq, a.seq
+      order by m.seq, a.seq
+    `)).rows.map((r) => ({
+			activityId: r.id,
+			title: r.title,
+			moduleId: r.module_id,
+			moduleTitle: r.module_title,
+			started: Number(r.started),
+			completed: Number(r.completed)
+		}));
+		return {
+			enrolled: Number(summary?.enrolled ?? 0),
+			started: Number(summary?.started ?? 0),
+			completed: Number(summary?.completed ?? 0),
+			avgProgress: Number(summary?.avg_progress ?? 0),
+			activities
+		};
+	}
+	async courseEnrollments(orgId, courseId, days) {
+		if (!await this.courseExists(orgId, courseId)) return null;
+		return (await this.db.execute(sql`
+      select
+        to_char(d.day, 'YYYY-MM-DD') as date,
+        count(${entitlements.id})::int as count
+      from generate_series(
+        (now() at time zone 'utc')::date - (${days} - 1),
+        (now() at time zone 'utc')::date,
+        interval '1 day'
+      ) as d(day)
+      left join ${entitlements}
+        on ${entitlements.orgId} = ${orgId}
+        and ${entitlements.contentId} = ${courseId}
+        and (${entitlements.grantedAt} at time zone 'utc')::date = d.day::date
+      group by d.day
+      order by d.day
+    `)).rows.map((r) => ({
+			date: r.date,
+			count: Number(r.count)
+		}));
+	}
+	async listStudents(orgId, query) {
+		const filters = [eq(orgUsers.orgId, orgId), eq(orgUsers.role, STUDENT_ROLE)];
+		const q = query.search?.trim();
+		if (q) {
+			const like = `%${q}%`;
+			filters.push(or(ilike(studentFirstName, like), ilike(studentLastName, like), ilike(users.email, like)));
+		}
+		const where = and(...filters);
+		const [totals] = await this.db.select({ total: sql`count(*)` }).from(orgUsers).innerJoin(users, eq(users.id, orgUsers.userId)).where(where);
+		return {
+			rows: (await this.db.select({
+				...studentProfileColumns,
+				status: orgUsers.status,
+				createdAt: orgUsers.createdAt,
+				entitlementCount: entitlementCountExpr,
+				avgProgress: avgProgressExpr,
+				lastActiveAt: lastActiveExpr
+			}).from(orgUsers).leftJoin(entitlements, and(eq(entitlements.orgId, orgUsers.orgId), eq(entitlements.orgUserId, orgUsers.id))).innerJoin(users, eq(users.id, orgUsers.userId)).leftJoin(user, eq(user.id, users.externalId)).where(where).groupBy(orgUsers.orgId, orgUsers.id, orgUsers.status, users.id, users.externalId, users.email, users.firstName, users.lastName, user.image).orderBy(...this.resolveOrder(query.sort)).limit(query.pageSize).offset((query.page - 1) * query.pageSize)).map(toStudent),
+			total: Number(totals?.total ?? 0),
+			page: query.page,
+			pageSize: query.pageSize
+		};
+	}
+	async getStudent(orgId, id) {
+		const [row] = await this.db.select({
+			...studentProfileColumns,
+			status: orgUsers.status,
+			createdAt: orgUsers.createdAt,
+			entitlementCount: entitlementCountExpr,
+			avgProgress: avgProgressExpr,
+			lastActiveAt: lastActiveExpr
+		}).from(orgUsers).leftJoin(entitlements, and(eq(entitlements.orgId, orgUsers.orgId), eq(entitlements.orgUserId, orgUsers.id))).innerJoin(users, eq(users.id, orgUsers.userId)).leftJoin(user, eq(user.id, users.externalId)).where(and(eq(orgUsers.orgId, orgId), eq(orgUsers.id, id), eq(orgUsers.role, STUDENT_ROLE))).groupBy(orgUsers.orgId, orgUsers.id, orgUsers.status, users.id, users.externalId, users.email, users.firstName, users.lastName, user.image).limit(1);
+		return row ? toStudent(row) : null;
+	}
+	async studentAnalytics(orgId, id) {
+		const [exists] = await this.db.select({ id: orgUsers.id }).from(orgUsers).where(and(eq(orgUsers.orgId, orgId), eq(orgUsers.id, id), eq(orgUsers.role, STUDENT_ROLE)));
+		if (!exists) return null;
+		const courses = (await this.db.execute(sql`
+      with cohort_courses as (
+        select distinct c.id, c.title
+        from content_access ca
+        join courses c on c.org_id = ca.org_id and c.id = ca.content_id
+        where ca.org_id = ${orgId}
+          and ca.org_user_id = ${id}
+      ),
+      acts as (
+        select a.course_id, a.id
+        from activities a
+        where a.org_id = ${orgId}
+          and a.course_id in (select id from cohort_courses)
+          and coalesce((a.settings ->> 'published')::boolean, true)
+      )
+      select
+        cc.id as course_id,
+        cc.title,
+        count(a.id)::int as total_activities,
+        count(pr.id) filter (where pr.completed_at is not null)::int as completed_activities,
+        min(pr.started_at) as started_at,
+        max(pr.updated_at) as last_activity_at,
+        (
+          select prc.completed_at from progress_records prc
+          where prc.org_id = ${orgId}
+            and prc.org_user_id = ${id}
+            and prc.target_type = 'course'
+            and prc.target_id = cc.id
+        ) as completed_at
+      from cohort_courses cc
+      left join acts a on a.course_id = cc.id
+      left join progress_records pr
+        on pr.org_id = ${orgId}
+        and pr.org_user_id = ${id}
+        and pr.target_type = 'activity'
+        and pr.target_id = a.id
+      group by cc.id, cc.title
+      order by cc.title
+    `)).rows.map((r) => {
+			const total = Number(r.total_activities);
+			const done = Number(r.completed_activities);
+			return {
+				courseId: r.course_id,
+				title: r.title,
+				totalActivities: total,
+				completedActivities: done,
+				progress: total > 0 ? Math.round(Math.min(done / total, 1) * 100) : 0,
+				startedAt: r.started_at ? new Date(r.started_at).toISOString() : null,
+				lastActivityAt: r.last_activity_at ? new Date(r.last_activity_at).toISOString() : null,
+				completedAt: r.completed_at ? new Date(r.completed_at).toISOString() : null
+			};
+		});
+		const started = courses.filter((c) => c.startedAt !== null).length;
+		const completed = courses.filter((c) => c.completedAt !== null).length;
+		const avgProgress = courses.length > 0 ? Math.round(courses.reduce((sum, c) => sum + c.progress, 0) / courses.length) : 0;
+		return {
+			enrolled: courses.length,
+			started,
+			completed,
+			avgProgress,
+			courses
+		};
+	}
+	resolveOrder(sort) {
+		const descending = sort?.startsWith("-") ?? false;
+		const field = sort ? descending ? sort.slice(1) : sort : "firstName";
+		const dir = descending ? desc : asc;
+		switch (field) {
+			case "email": return [dir(users.email)];
+			case "entitlementCount": return [dir(entitlementCountExpr)];
+			case "avgProgress": return [dir(avgProgressExpr)];
+			case "joinedAt": return [dir(orgUsers.createdAt)];
+			case "lastActiveAt": return [dir(lastActiveExpr)];
+			case "lastName": return [dir(studentLastName), dir(studentFirstName)];
+			default: return [dir(studentFirstName), dir(studentLastName)];
+		}
+	}
+	async communityAnalytics(orgId, communityId) {
+		const [community] = await this.db.select({ id: communities.id }).from(communities).where(and(eq(communities.orgId, orgId), eq(communities.id, communityId))).limit(1);
+		if (!community) return null;
+		const opens = grantOpens(entitlements, sql`${communityId}`, "community");
+		const lapsed = and(eq(entitlements.orgId, orgId), eq(entitlements.status, "active"), grantExpired(entitlements.expiresAt), opens);
+		const recent = sql`now() - interval '30 days'`;
+		const [[members], [lapsedGrants], authors, postsPerSpace, commentsPerPost, [sent], [postFlagRow], [commentFlagRow], [messageFlagRow], lapsedHolders] = await Promise.all([
+			this.db.select({ count: sql`cast(count(distinct ${contentAccess.orgUserId}) as int)` }).from(contentAccess).where(and(eq(contentAccess.orgId, orgId), eq(contentAccess.contentId, communityId))),
+			this.db.select({ count: sql`cast(count(*) as int)` }).from(entitlements).where(lapsed),
+			union(this.db.select({ id: posts.orgUserId }).from(posts).where(and(eq(posts.orgId, orgId), eq(posts.communityId, communityId), sql`${posts.createdAt} >= ${recent}`)), this.db.select({ id: comments.orgUserId }).from(comments).where(and(eq(comments.orgId, orgId), eq(comments.communityId, communityId), sql`${comments.createdAt} >= ${recent}`)), this.db.select({ id: messages.orgUserId }).from(messages).where(and(eq(messages.orgId, orgId), eq(messages.communityId, communityId), sql`${messages.createdAt} >= ${recent}`))),
+			this.db.select({
+				spaceId: spaces.id,
+				count: sql`cast(count(${posts.id}) as int)`
+			}).from(spaces).leftJoin(posts, and(eq(posts.orgId, spaces.orgId), eq(posts.spaceId, spaces.id), eq(posts.status, "published"))).where(and(eq(spaces.orgId, orgId), eq(spaces.communityId, communityId))).groupBy(spaces.id),
+			this.db.select({
+				postId: posts.id,
+				count: sql`cast(count(${comments.id}) as int)`
+			}).from(posts).leftJoin(comments, and(eq(comments.orgId, posts.orgId), eq(comments.postId, posts.id), eq(comments.status, "published"))).where(and(eq(posts.orgId, orgId), eq(posts.communityId, communityId), eq(posts.status, "published"))).groupBy(posts.id),
+			this.db.select({ count: sql`cast(count(*) as int)` }).from(messages).where(and(eq(messages.orgId, orgId), eq(messages.communityId, communityId))),
+			this.db.select({
+				raised: sql`cast(count(*) as int)`,
+				resolved: sql`cast(count(*) filter (where ${postFlags.resolvedAt} is not null) as int)`
+			}).from(postFlags).innerJoin(posts, and(eq(posts.orgId, postFlags.orgId), eq(posts.id, postFlags.postId))).where(and(eq(postFlags.orgId, orgId), eq(posts.communityId, communityId))),
+			this.db.select({
+				raised: sql`cast(count(*) as int)`,
+				resolved: sql`cast(count(*) filter (where ${commentFlags.resolvedAt} is not null) as int)`
+			}).from(commentFlags).innerJoin(comments, and(eq(comments.orgId, commentFlags.orgId), eq(comments.id, commentFlags.commentId))).where(and(eq(commentFlags.orgId, orgId), eq(comments.communityId, communityId))),
+			this.db.select({
+				raised: sql`cast(count(*) as int)`,
+				resolved: sql`cast(count(*) filter (where ${messageFlags.resolvedAt} is not null) as int)`
+			}).from(messageFlags).where(and(eq(messageFlags.orgId, orgId), eq(messageFlags.communityId, communityId))),
+			this.db.select({ orgUserId: entitlements.orgUserId }).from(entitlements).where(lapsed).groupBy(entitlements.orgUserId)
+		]);
+		const holderIds = lapsedHolders.map((row) => row.orgUserId);
+		const [renewed] = holderIds.length === 0 ? [{ count: 0 }] : await this.db.select({ count: sql`cast(count(distinct ${contentAccess.orgUserId}) as int)` }).from(contentAccess).where(and(eq(contentAccess.orgId, orgId), eq(contentAccess.contentId, communityId), inArray(contentAccess.orgUserId, holderIds)));
+		const raised = Number(postFlagRow?.raised ?? 0) + Number(commentFlagRow?.raised ?? 0) + Number(messageFlagRow?.raised ?? 0);
+		const resolved = Number(postFlagRow?.resolved ?? 0) + Number(commentFlagRow?.resolved ?? 0) + Number(messageFlagRow?.resolved ?? 0);
+		return {
+			memberCount: Number(members?.count ?? 0),
+			activeMembers: authors.length,
+			postsPerSpace: postsPerSpace.map((row) => ({
+				spaceId: row.spaceId,
+				count: Number(row.count)
+			})),
+			commentsPerPost: commentsPerPost.map((row) => ({
+				postId: row.postId,
+				count: Number(row.count)
+			})),
+			messagesSent: Number(sent?.count ?? 0),
+			flagsRaised: raised,
+			flagsResolved: resolved,
+			grantsLapsed: Number(lapsedGrants?.count ?? 0),
+			grantsRenewed: Number(renewed?.count ?? 0)
+		};
+	}
+	async communityMembers(orgId, communityId, query) {
+		const [community] = await this.db.select({ id: communities.id }).from(communities).where(and(eq(communities.orgId, orgId), eq(communities.id, communityId))).limit(1);
+		if (!community) return null;
+		const holds = exists(this.db.select({ id: contentAccess.entitlementId }).from(contentAccess).where(and(eq(contentAccess.orgId, orgUsers.orgId), eq(contentAccess.orgUserId, orgUsers.id), eq(contentAccess.contentId, communityId))));
+		const filters = [eq(orgUsers.orgId, orgId), holds];
+		const q = query.search?.trim();
+		if (q) {
+			const like = `%${q}%`;
+			filters.push(or(ilike(studentFirstName, like), ilike(studentLastName, like), ilike(users.email, like)));
+		}
+		const where = and(...filters);
+		const [totals] = await this.db.select({ total: sql`count(*)` }).from(orgUsers).innerJoin(users, eq(users.id, orgUsers.userId)).where(where);
+		return {
+			rows: (await this.db.select({
+				...orgUserProfileColumns,
+				role: orgUsers.role
+			}).from(orgUsers).innerJoin(users, eq(users.id, orgUsers.userId)).leftJoin(user, eq(user.id, users.externalId)).where(where).orderBy(asc(users.firstName), asc(users.lastName), asc(orgUsers.id)).limit(query.pageSize).offset((query.page - 1) * query.pageSize)).map((row) => ({
+				...row,
+				image: row.image ?? null
+			})),
+			total: Number(totals?.total ?? 0),
+			page: query.page,
+			pageSize: query.pageSize
+		};
+	}
+};
+translateDbErrors(DrizzleAdminRepository);
+//#endregion
+export { DrizzleAdminRepository };
+
+//# sourceMappingURL=admin.js.map