@headless-lms/core 0.1.0

package/dist/reporting/students/service.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from "../../types/ports.js";
+import "../../shared/ports.js";
+import { Page, Student, StudentsQuery } from "./model.js";
+import { StudentsReportRepository, StudentsReportService } from "./ports.js";
+//#region src/reporting/students/service.d.ts
+type StudentsReportServiceParams = {
+  repo: StudentsReportRepository;
+  logger?: Logger;
+};
+declare class StudentsReportServiceImpl implements StudentsReportService {
+  private readonly repo;
+  private readonly logger;
+  constructor(params: StudentsReportServiceParams);
+  list(orgId: string, query: StudentsQuery): Promise<Page<Student>>;
+  get(orgId: string, id: string): Promise<Student | null>;
+}
+//#endregion
+export { StudentsReportServiceImpl, StudentsReportServiceParams };
+//# sourceMappingURL=service.d.ts.map

package/dist/reporting/students/service.js

@@ -0,0 +1,20 @@
+import { noopLogger } from "../../shared/logger.js";
+//#region src/reporting/students/service.ts
+var StudentsReportServiceImpl = class {
+	repo;
+	logger;
+	constructor(params) {
+		this.repo = params.repo;
+		this.logger = params.logger ?? noopLogger;
+	}
+	list(orgId, query) {
+		return this.repo.list(orgId, query);
+	}
+	get(orgId, id) {
+		return this.repo.findById(orgId, id);
+	}
+};
+//#endregion
+export { StudentsReportServiceImpl };
+
+//# sourceMappingURL=service.js.map

package/dist/reporting/students/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","names":[],"sources":["../../../src/reporting/students/service.ts"],"sourcesContent":["// reporting/students — service implementation (inbound port).\nimport type { Page, Student, StudentsQuery } from './model.js';\nimport type { StudentsReportRepository, StudentsReportService } from './ports.js';\nimport type { Logger } from '../../shared/ports.js';\nimport { noopLogger } from '../../shared/logger.js';\n\nexport type StudentsReportServiceParams = {\n  repo: StudentsReportRepository;\n  logger?: Logger;\n};\n\nexport class StudentsReportServiceImpl implements StudentsReportService {\n  private readonly repo: StudentsReportRepository;\n  private readonly logger: Logger;\n\n  constructor(params: StudentsReportServiceParams) {\n    this.repo = params.repo;\n    this.logger = params.logger ?? noopLogger;\n  }\n\n  list(orgId: string, query: StudentsQuery): Promise<Page<Student>> {\n    return this.repo.list(orgId, query);\n  }\n\n  get(orgId: string, id: string): Promise<Student | null> {\n    return this.repo.findById(orgId, id);\n  }\n}\n"],"mappings":";;AAWA,IAAa,4BAAb,MAAwE;CACtE;CACA;CAEA,YAAY,QAAqC;EAC/C,KAAK,OAAO,OAAO;EACnB,KAAK,SAAS,OAAO,UAAU;CACjC;CAEA,KAAK,OAAe,OAA8C;EAChE,OAAO,KAAK,KAAK,KAAK,OAAO,KAAK;CACpC;CAEA,IAAI,OAAe,IAAqC;EACtD,OAAO,KAAK,KAAK,SAAS,OAAO,EAAE;CACrC;AACF"}

package/dist/shared/errors.d.ts

@@ -0,0 +1,22 @@
+//#region src/shared/errors.d.ts
+/** A command's target does not exist in this org. Queries return null for the
+ *  same situation — a missing row is a normal answer to a question, but a
+ *  failed precondition for a command. */
+declare class NotFoundError extends Error {
+  readonly resource: string;
+  readonly id: string;
+  constructor(resource: string, id: string);
+}
+/** A command conflicts with existing state (duplicate email, already linked,
+ *  …). The HTTP layer maps this to 409. */
+declare class ConflictError extends Error {
+  constructor(message: string);
+}
+/** The caller is authenticated but not permitted to perform this command.
+ *  The HTTP layer maps this to 403. */
+declare class ForbiddenError extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { ConflictError, ForbiddenError, NotFoundError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/shared/errors.js

@@ -0,0 +1,34 @@
+//#region src/shared/errors.ts
+/** A command's target does not exist in this org. Queries return null for the
+*  same situation — a missing row is a normal answer to a question, but a
+*  failed precondition for a command. */
+var NotFoundError = class extends Error {
+	resource;
+	id;
+	constructor(resource, id) {
+		super(`${resource} not found`);
+		this.resource = resource;
+		this.id = id;
+		this.name = "NotFoundError";
+	}
+};
+/** A command conflicts with existing state (duplicate email, already linked,
+*  …). The HTTP layer maps this to 409. */
+var ConflictError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ConflictError";
+	}
+};
+/** The caller is authenticated but not permitted to perform this command.
+*  The HTTP layer maps this to 403. */
+var ForbiddenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ForbiddenError";
+	}
+};
+//#endregion
+export { ConflictError, ForbiddenError, NotFoundError };
+
+//# sourceMappingURL=errors.js.map

package/dist/shared/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/shared/errors.ts"],"sourcesContent":["// Cross-cutting domain errors. Like `../shared/ports.js`, this file is\n// importable from any context; the central HTTP error handler maps these to\n// status codes so routes never hand-roll error replies.\n\n/** A command's target does not exist in this org. Queries return null for the\n *  same situation — a missing row is a normal answer to a question, but a\n *  failed precondition for a command. */\nexport class NotFoundError extends Error {\n  constructor(\n    readonly resource: string,\n    readonly id: string,\n  ) {\n    super(`${resource} not found`);\n    this.name = 'NotFoundError';\n  }\n}\n\n/** A command conflicts with existing state (duplicate email, already linked,\n *  …). The HTTP layer maps this to 409. */\nexport class ConflictError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ConflictError';\n  }\n}\n\n/** The caller is authenticated but not permitted to perform this command.\n *  The HTTP layer maps this to 403. */\nexport class ForbiddenError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ForbiddenError';\n  }\n}\n"],"mappings":";;;;AAOA,IAAa,gBAAb,cAAmC,MAAM;CAE5B;CACA;CAFX,YACE,UACA,IACA;EACA,MAAM,GAAG,SAAS,WAAW;EAHpB,KAAA,WAAA;EACA,KAAA,KAAA;EAGT,KAAK,OAAO;CACd;AACF;;;AAIA,IAAa,gBAAb,cAAmC,MAAM;CACvC,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF;;;AAIA,IAAa,iBAAb,cAAoC,MAAM;CACxC,YAAY,SAAiB;EAC3B,MAAM,OAAO;EACb,KAAK,OAAO;CACd;AACF"}

package/dist/shared/events.d.ts

@@ -0,0 +1,31 @@
+import { DomainEvent, EventMetadata, JsonValue } from "../types/shared.js";
+import { EventDefinition, EventParseResult, MakeEventInput } from "../types/events.js";
+import "../types/index.js";
+import { z } from "zod";
+//#region src/shared/events.d.ts
+declare class InvalidDomainEventError extends Error {
+  constructor(type: string, detail: string);
+}
+declare const eventIdSchema: z.ZodString;
+declare const eventJsonValueSchema: z.ZodType<JsonValue>;
+declare const eventMetadataSchema: z.ZodType<EventMetadata>;
+type VersionedDomainEvent<TData = unknown, TType extends string = string, TVersion extends number = number> = DomainEvent<TData, TType, TVersion> & {
+  readonly version: TVersion;
+  readonly occurredAt: string;
+  readonly data: TData;
+};
+interface RuntimeEventDefinition<E extends VersionedDomainEvent, TMakeData = E['data']> extends EventDefinition<E, TMakeData> {
+  readonly dataSchema: z.ZodType;
+  readonly eventSchema: z.ZodType<E>;
+}
+type EventOf<TDefinition extends EventDefinition<DomainEvent, unknown>> = TDefinition extends EventDefinition<infer E, unknown> ? E : never;
+type EventOfValues<TDefinitions extends Record<string, EventDefinition<DomainEvent, unknown>>> = EventOf<TDefinitions[keyof TDefinitions]>;
+interface DefineEventInput<TType extends string, TVersion extends number, TDataSchema extends z.ZodType> {
+  readonly type: TType;
+  readonly version: TVersion;
+  readonly data: TDataSchema;
+}
+declare function defineEvent<const TType extends string, const TVersion extends number, TDataSchema extends z.ZodType>(input: DefineEventInput<TType, TVersion, TDataSchema>): RuntimeEventDefinition<VersionedDomainEvent<z.output<TDataSchema>, TType, TVersion>, z.input<TDataSchema>>;
+//#endregion
+export { DefineEventInput, type EventDefinition, EventOf, EventOfValues, type EventParseResult, InvalidDomainEventError, type MakeEventInput, RuntimeEventDefinition, VersionedDomainEvent, defineEvent, eventIdSchema, eventJsonValueSchema, eventMetadataSchema };
+//# sourceMappingURL=events.d.ts.map

package/dist/shared/events.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+//#region src/shared/events.ts
+var InvalidDomainEventError = class extends Error {
+	constructor(type, detail) {
+		super(`invalid ${type} event: ${detail}`);
+		this.name = "InvalidDomainEventError";
+	}
+};
+const eventIdSchema = z.string().trim().min(1);
+const eventJsonValueSchema = z.lazy(() => z.union([
+	z.null(),
+	z.string(),
+	z.number().finite(),
+	z.boolean(),
+	z.array(eventJsonValueSchema),
+	z.record(z.string(), eventJsonValueSchema)
+]));
+const eventMetadataSchema = z.record(z.string(), eventJsonValueSchema);
+function defineEvent(input) {
+	const makeInputSchema = z.object({
+		orgId: eventIdSchema,
+		data: input.data,
+		metadata: eventMetadataSchema.optional()
+	}).strict();
+	const eventSchema = z.object({
+		type: z.literal(input.type),
+		version: z.literal(input.version),
+		id: eventIdSchema,
+		orgId: eventIdSchema,
+		occurredAt: z.string().trim().min(1),
+		data: input.data,
+		metadata: eventMetadataSchema.optional()
+	}).strict();
+	return {
+		type: input.type,
+		version: input.version,
+		dataSchema: input.data,
+		eventSchema,
+		make(value) {
+			const result = makeInputSchema.safeParse(value);
+			if (!result.success) throw invalidEvent(input.type, result.error);
+			return {
+				type: input.type,
+				version: input.version,
+				...result.data
+			};
+		},
+		is(event) {
+			return eventSchema.safeParse(event).success;
+		},
+		parse(event) {
+			const result = eventSchema.safeParse(event);
+			if (!result.success) throw invalidEvent(input.type, result.error);
+			return result.data;
+		},
+		safeParse(event) {
+			const result = eventSchema.safeParse(event);
+			if (!result.success) return {
+				success: false,
+				error: invalidEvent(input.type, result.error)
+			};
+			return {
+				success: true,
+				data: result.data
+			};
+		}
+	};
+}
+function invalidEvent(type, error) {
+	return new InvalidDomainEventError(type, error.issues.map((issue) => `${issue.path.join(".") || "event"}: ${issue.message}`).join("; "));
+}
+//#endregion
+export { InvalidDomainEventError, defineEvent, eventIdSchema, eventJsonValueSchema, eventMetadataSchema };
+
+//# sourceMappingURL=events.js.map

package/dist/shared/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../src/shared/events.ts"],"sourcesContent":["import { z } from 'zod';\nimport type {\n  ContractNewDomainEvent,\n  DomainEvent,\n  EventDefinition,\n  EventMetadata,\n  EventParseResult,\n  JsonValue,\n  MakeEventInput,\n} from '../types/index.js';\n\nexport class InvalidDomainEventError extends Error {\n  constructor(type: string, detail: string) {\n    super(`invalid ${type} event: ${detail}`);\n    this.name = 'InvalidDomainEventError';\n  }\n}\n\nexport const eventIdSchema: z.ZodString = z.string().trim().min(1);\n\nexport const eventJsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>\n  z.union([\n    z.null(),\n    z.string(),\n    z.number().finite(),\n    z.boolean(),\n    z.array(eventJsonValueSchema),\n    z.record(z.string(), eventJsonValueSchema),\n  ]),\n);\n\nexport const eventMetadataSchema: z.ZodType<EventMetadata> = z.record(\n  z.string(),\n  eventJsonValueSchema,\n);\n\nexport type VersionedDomainEvent<\n  TData = unknown,\n  TType extends string = string,\n  TVersion extends number = number,\n> = DomainEvent<TData, TType, TVersion> & {\n  readonly version: TVersion;\n  readonly occurredAt: string;\n  readonly data: TData;\n};\n\nexport interface RuntimeEventDefinition<\n  E extends VersionedDomainEvent,\n  TMakeData = E['data'],\n> extends EventDefinition<E, TMakeData> {\n  readonly dataSchema: z.ZodType;\n  readonly eventSchema: z.ZodType<E>;\n}\n\nexport type EventOf<TDefinition extends EventDefinition<DomainEvent, unknown>> =\n  TDefinition extends EventDefinition<infer E, unknown> ? E : never;\n\nexport type EventOfValues<TDefinitions extends Record<string, EventDefinition<DomainEvent, unknown>>> =\n  EventOf<TDefinitions[keyof TDefinitions]>;\n\nexport interface DefineEventInput<\n  TType extends string,\n  TVersion extends number,\n  TDataSchema extends z.ZodType,\n> {\n  readonly type: TType;\n  readonly version: TVersion;\n  readonly data: TDataSchema;\n}\n\nexport function defineEvent<\n  const TType extends string,\n  const TVersion extends number,\n  TDataSchema extends z.ZodType,\n>(\n  input: DefineEventInput<TType, TVersion, TDataSchema>,\n): RuntimeEventDefinition<\n  VersionedDomainEvent<z.output<TDataSchema>, TType, TVersion>,\n  z.input<TDataSchema>\n> {\n  type Event = VersionedDomainEvent<z.output<TDataSchema>, TType, TVersion>;\n  const makeInputSchema = z.object({\n    orgId: eventIdSchema,\n    data: input.data,\n    metadata: eventMetadataSchema.optional(),\n  }).strict();\n  const eventSchema = z.object({\n    type: z.literal(input.type),\n    version: z.literal(input.version),\n    id: eventIdSchema,\n    orgId: eventIdSchema,\n    occurredAt: z.string().trim().min(1),\n    data: input.data,\n    metadata: eventMetadataSchema.optional(),\n  }).strict();\n\n  return {\n    type: input.type,\n    version: input.version,\n    dataSchema: input.data,\n    eventSchema: eventSchema as unknown as z.ZodType<Event>,\n    make(value: MakeEventInput<z.input<TDataSchema>>) {\n      const result = makeInputSchema.safeParse(value);\n      if (!result.success) {\n        throw invalidEvent(input.type, result.error);\n      }\n      return {\n        type: input.type,\n        version: input.version,\n        ...result.data,\n      } as ContractNewDomainEvent<Event>;\n    },\n    is(event: unknown): event is Event {\n      return eventSchema.safeParse(event).success;\n    },\n    parse(event: unknown) {\n      const result = eventSchema.safeParse(event);\n      if (!result.success) {\n        throw invalidEvent(input.type, result.error);\n      }\n      return result.data as Event;\n    },\n    safeParse(event: unknown): EventParseResult<Event> {\n      const result = eventSchema.safeParse(event);\n      if (!result.success) {\n        return { success: false, error: invalidEvent(input.type, result.error) };\n      }\n      return { success: true, data: result.data as Event };\n    },\n  };\n}\n\nfunction invalidEvent(type: string, error: z.ZodError): InvalidDomainEventError {\n  return new InvalidDomainEventError(\n    type,\n    error.issues.map((issue) => `${issue.path.join('.') || 'event'}: ${issue.message}`).join('; '),\n  );\n}\n\nexport type {\n  EventDefinition,\n  EventParseResult,\n  MakeEventInput,\n};\n"],"mappings":";;AAWA,IAAa,0BAAb,cAA6C,MAAM;CACjD,YAAY,MAAc,QAAgB;EACxC,MAAM,WAAW,KAAK,UAAU,QAAQ;EACxC,KAAK,OAAO;CACd;AACF;AAEA,MAAa,gBAA6B,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;AAEjE,MAAa,uBAA6C,EAAE,WAC1D,EAAE,MAAM;CACN,EAAE,KAAK;CACP,EAAE,OAAO;CACT,EAAE,OAAO,CAAC,CAAC,OAAO;CAClB,EAAE,QAAQ;CACV,EAAE,MAAM,oBAAoB;CAC5B,EAAE,OAAO,EAAE,OAAO,GAAG,oBAAoB;AAC3C,CAAC,CACH;AAEA,MAAa,sBAAgD,EAAE,OAC7D,EAAE,OAAO,GACT,oBACF;AAoCA,SAAgB,YAKd,OAIA;CAEA,MAAM,kBAAkB,EAAE,OAAO;EAC/B,OAAO;EACP,MAAM,MAAM;EACZ,UAAU,oBAAoB,SAAS;CACzC,CAAC,CAAC,CAAC,OAAO;CACV,MAAM,cAAc,EAAE,OAAO;EAC3B,MAAM,EAAE,QAAQ,MAAM,IAAI;EAC1B,SAAS,EAAE,QAAQ,MAAM,OAAO;EAChC,IAAI;EACJ,OAAO;EACP,YAAY,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;EACnC,MAAM,MAAM;EACZ,UAAU,oBAAoB,SAAS;CACzC,CAAC,CAAC,CAAC,OAAO;CAEV,OAAO;EACL,MAAM,MAAM;EACZ,SAAS,MAAM;EACf,YAAY,MAAM;EACL;EACb,KAAK,OAA6C;GAChD,MAAM,SAAS,gBAAgB,UAAU,KAAK;GAC9C,IAAI,CAAC,OAAO,SACV,MAAM,aAAa,MAAM,MAAM,OAAO,KAAK;GAE7C,OAAO;IACL,MAAM,MAAM;IACZ,SAAS,MAAM;IACf,GAAG,OAAO;GACZ;EACF;EACA,GAAG,OAAgC;GACjC,OAAO,YAAY,UAAU,KAAK,CAAC,CAAC;EACtC;EACA,MAAM,OAAgB;GACpB,MAAM,SAAS,YAAY,UAAU,KAAK;GAC1C,IAAI,CAAC,OAAO,SACV,MAAM,aAAa,MAAM,MAAM,OAAO,KAAK;GAE7C,OAAO,OAAO;EAChB;EACA,UAAU,OAAyC;GACjD,MAAM,SAAS,YAAY,UAAU,KAAK;GAC1C,IAAI,CAAC,OAAO,SACV,OAAO;IAAE,SAAS;IAAO,OAAO,aAAa,MAAM,MAAM,OAAO,KAAK;GAAE;GAEzE,OAAO;IAAE,SAAS;IAAM,MAAM,OAAO;GAAc;EACrD;CACF;AACF;AAEA,SAAS,aAAa,MAAc,OAA4C;CAC9E,OAAO,IAAI,wBACT,MACA,MAAM,OAAO,KAAK,UAAU,GAAG,MAAM,KAAK,KAAK,GAAG,KAAK,QAAQ,IAAI,MAAM,SAAS,CAAC,CAAC,KAAK,IAAI,CAC/F;AACF"}

package/dist/shared/id.d.ts

@@ -0,0 +1,44 @@
+//#region src/shared/id.d.ts
+/**
+ * Prefixed, KSUID-bodied string ids — `${prefix}_${ksuid}`, e.g. `org_2QZ4mK...`.
+ *
+ * The body is a real KSUID (27-char base62, 4-byte timestamp + 16 random bytes),
+ * so ids are lexicographically time-sortable. The prefix marks the entity type at
+ * a glance. A core utility (one implementation, nothing to swap), called directly
+ * by core services and used as the Drizzle `.$defaultFn` for every domain id column.
+ */
+declare const ID_PREFIXES: {
+  readonly organization: "org";
+  readonly user: "usr";
+  readonly student: "stu";
+  readonly orgUser: "orm";
+  readonly invite: "ivt";
+  readonly course: "crs";
+  readonly module: "mod";
+  readonly activity: "act";
+  readonly activityAsset: "aca";
+  readonly download: "dwn";
+  readonly downloadAsset: "dla";
+  readonly asset: "ast";
+  readonly entitlement: "ent";
+  readonly progress: "prg";
+  readonly credential: "crd";
+  readonly connection: "con";
+  readonly event: "evt";
+  readonly automation: "atm";
+  readonly automationRun: "run";
+  readonly comment: "cmt";
+  readonly commentReport: "crp";
+};
+type IdType = keyof typeof ID_PREFIXES;
+/** A bare KSUID body (27-char base62, time-sortable), no prefix. */
+declare function ksuid(): string;
+/** Attach an arbitrary prefix to a fresh KSUID — `${prefix}_${ksuid}`. */
+declare function prefixId(prefix: string): string;
+/** Generate a prefixed, time-sortable id for the given domain entity type. */
+declare function genId(type: IdType): string;
+/** True when `value` carries the prefix for `type` (shape check only, not existence). */
+declare function isId(type: IdType, value: string): boolean;
+//#endregion
+export { ID_PREFIXES, IdType, genId, isId, ksuid, prefixId };
+//# sourceMappingURL=id.d.ts.map

package/dist/shared/id.js

@@ -0,0 +1,53 @@
+import KSUID from "ksuid";
+//#region src/shared/id.ts
+/**
+* Prefixed, KSUID-bodied string ids — `${prefix}_${ksuid}`, e.g. `org_2QZ4mK...`.
+*
+* The body is a real KSUID (27-char base62, 4-byte timestamp + 16 random bytes),
+* so ids are lexicographically time-sortable. The prefix marks the entity type at
+* a glance. A core utility (one implementation, nothing to swap), called directly
+* by core services and used as the Drizzle `.$defaultFn` for every domain id column.
+*/
+const ID_PREFIXES = {
+	organization: "org",
+	user: "usr",
+	student: "stu",
+	orgUser: "orm",
+	invite: "ivt",
+	course: "crs",
+	module: "mod",
+	activity: "act",
+	activityAsset: "aca",
+	download: "dwn",
+	downloadAsset: "dla",
+	asset: "ast",
+	entitlement: "ent",
+	progress: "prg",
+	credential: "crd",
+	connection: "con",
+	event: "evt",
+	automation: "atm",
+	automationRun: "run",
+	comment: "cmt",
+	commentReport: "crp"
+};
+/** A bare KSUID body (27-char base62, time-sortable), no prefix. */
+function ksuid() {
+	return KSUID.randomSync().string;
+}
+/** Attach an arbitrary prefix to a fresh KSUID — `${prefix}_${ksuid}`. */
+function prefixId(prefix) {
+	return `${prefix}_${ksuid()}`;
+}
+/** Generate a prefixed, time-sortable id for the given domain entity type. */
+function genId(type) {
+	return prefixId(ID_PREFIXES[type]);
+}
+/** True when `value` carries the prefix for `type` (shape check only, not existence). */
+function isId(type, value) {
+	return value.startsWith(`${ID_PREFIXES[type]}_`);
+}
+//#endregion
+export { ID_PREFIXES, genId, isId, ksuid, prefixId };
+
+//# sourceMappingURL=id.js.map

package/dist/shared/id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.js","names":[],"sources":["../../src/shared/id.ts"],"sourcesContent":["import KSUID from 'ksuid';\n\n/**\n * Prefixed, KSUID-bodied string ids — `${prefix}_${ksuid}`, e.g. `org_2QZ4mK...`.\n *\n * The body is a real KSUID (27-char base62, 4-byte timestamp + 16 random bytes),\n * so ids are lexicographically time-sortable. The prefix marks the entity type at\n * a glance. A core utility (one implementation, nothing to swap), called directly\n * by core services and used as the Drizzle `.$defaultFn` for every domain id column.\n */\nexport const ID_PREFIXES = {\n  organization: 'org',\n  user: 'usr',\n  student: 'stu',\n  orgUser: 'orm',\n  invite: 'ivt',\n  course: 'crs',\n  module: 'mod',\n  activity: 'act',\n  activityAsset: 'aca',\n  download: 'dwn',\n  downloadAsset: 'dla',\n  asset: 'ast',\n  entitlement: 'ent',\n  progress: 'prg',\n  credential: 'crd',\n  connection: 'con',\n  event: 'evt',\n  automation: 'atm',\n  automationRun: 'run',\n  comment: 'cmt',\n  commentReport: 'crp',\n} as const;\n\nexport type IdType = keyof typeof ID_PREFIXES;\n\n/** A bare KSUID body (27-char base62, time-sortable), no prefix. */\nexport function ksuid(): string {\n  return KSUID.randomSync().string;\n}\n\n/** Attach an arbitrary prefix to a fresh KSUID — `${prefix}_${ksuid}`. */\nexport function prefixId(prefix: string): string {\n  return `${prefix}_${ksuid()}`;\n}\n\n/** Generate a prefixed, time-sortable id for the given domain entity type. */\nexport function genId(type: IdType): string {\n  return prefixId(ID_PREFIXES[type]);\n}\n\n/** True when `value` carries the prefix for `type` (shape check only, not existence). */\nexport function isId(type: IdType, value: string): boolean {\n  return value.startsWith(`${ID_PREFIXES[type]}_`);\n}\n"],"mappings":";;;;;;;;;;AAUA,MAAa,cAAc;CACzB,cAAc;CACd,MAAM;CACN,SAAS;CACT,SAAS;CACT,QAAQ;CACR,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,eAAe;CACf,UAAU;CACV,eAAe;CACf,OAAO;CACP,aAAa;CACb,UAAU;CACV,YAAY;CACZ,YAAY;CACZ,OAAO;CACP,YAAY;CACZ,eAAe;CACf,SAAS;CACT,eAAe;AACjB;;AAKA,SAAgB,QAAgB;CAC9B,OAAO,MAAM,WAAW,CAAC,CAAC;AAC5B;;AAGA,SAAgB,SAAS,QAAwB;CAC/C,OAAO,GAAG,OAAO,GAAG,MAAM;AAC5B;;AAGA,SAAgB,MAAM,MAAsB;CAC1C,OAAO,SAAS,YAAY,KAAK;AACnC;;AAGA,SAAgB,KAAK,MAAc,OAAwB;CACzD,OAAO,MAAM,WAAW,GAAG,YAAY,MAAM,EAAE;AACjD"}

package/dist/shared/invite-token.d.ts

@@ -0,0 +1,9 @@
+//#region src/shared/invite-token.d.ts
+declare function generateInviteToken(): {
+  token: string;
+  tokenHash: string;
+};
+declare function hashInviteToken(token: string): string;
+//#endregion
+export { generateInviteToken, hashInviteToken };
+//# sourceMappingURL=invite-token.d.ts.map

package/dist/shared/invite-token.js

@@ -0,0 +1,16 @@
+import { createHash, randomBytes } from "node:crypto";
+//#region src/shared/invite-token.ts
+function generateInviteToken() {
+	const token = randomBytes(32).toString("base64url");
+	return {
+		token,
+		tokenHash: hashInviteToken(token)
+	};
+}
+function hashInviteToken(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+//#endregion
+export { generateInviteToken, hashInviteToken };
+
+//# sourceMappingURL=invite-token.js.map

package/dist/shared/invite-token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite-token.js","names":[],"sources":["../../src/shared/invite-token.ts"],"sourcesContent":["// Domain-owned invite tokens: an unguessable secret in the emailed link, only\n// its sha256 at rest. Same core-utility status as id.ts (one implementation,\n// nothing to swap).\nimport { createHash, randomBytes } from 'node:crypto';\n\nexport function generateInviteToken(): { token: string; tokenHash: string } {\n  const token = randomBytes(32).toString('base64url');\n  return { token, tokenHash: hashInviteToken(token) };\n}\n\nexport function hashInviteToken(token: string): string {\n  return createHash('sha256').update(token).digest('hex');\n}\n"],"mappings":";;AAKA,SAAgB,sBAA4D;CAC1E,MAAM,QAAQ,YAAY,EAAE,CAAC,CAAC,SAAS,WAAW;CAClD,OAAO;EAAE;EAAO,WAAW,gBAAgB,KAAK;CAAE;AACpD;AAEA,SAAgB,gBAAgB,OAAuB;CACrD,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AACxD"}

package/dist/shared/logger.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from "../types/ports.js";
+import "./ports.js";
+//#region src/shared/logger.d.ts
+/** Discards everything. The default for constructors the container overrides. */
+declare const noopLogger: Logger;
+interface CapturedLog {
+  level: 'debug' | 'info' | 'warn' | 'error';
+  msg: string;
+  meta: Record<string, unknown>;
+}
+/** In-memory logger for tests: every entry (from the root or any child) lands
+ *  in `entries`, with child bindings merged into meta. */
+declare function createCapturingLogger(): {
+  logger: Logger;
+  entries: CapturedLog[];
+};
+//#endregion
+export { CapturedLog, createCapturingLogger, noopLogger };
+//# sourceMappingURL=logger.d.ts.map

package/dist/shared/logger.js

@@ -0,0 +1,44 @@
+//#region src/shared/logger.ts
+/** Discards everything. The default for constructors the container overrides. */
+const noopLogger = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	child: () => noopLogger
+};
+/** In-memory logger for tests: every entry (from the root or any child) lands
+*  in `entries`, with child bindings merged into meta. */
+function createCapturingLogger() {
+	const entries = [];
+	const make = (bindings) => {
+		const record = (level) => (msg, meta) => {
+			entries.push({
+				level,
+				msg,
+				meta: {
+					...bindings,
+					...meta
+				}
+			});
+		};
+		return {
+			debug: record("debug"),
+			info: record("info"),
+			warn: record("warn"),
+			error: record("error"),
+			child: (more) => make({
+				...bindings,
+				...more
+			})
+		};
+	};
+	return {
+		logger: make({}),
+		entries
+	};
+}
+//#endregion
+export { createCapturingLogger, noopLogger };
+
+//# sourceMappingURL=logger.js.map

package/dist/shared/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":[],"sources":["../../src/shared/logger.ts"],"sourcesContent":["// Test/default implementations of the Logger port. The real pino-backed\n// implementation lives in adapters/logging; these exist so constructors can\n// default to a silent logger and tests can assert on emitted entries.\nimport type { Logger } from './ports.js';\n\n/** Discards everything. The default for constructors the container overrides. */\nexport const noopLogger: Logger = {\n  debug: () => {},\n  info: () => {},\n  warn: () => {},\n  error: () => {},\n  child: () => noopLogger,\n};\n\nexport interface CapturedLog {\n  level: 'debug' | 'info' | 'warn' | 'error';\n  msg: string;\n  meta: Record<string, unknown>;\n}\n\n/** In-memory logger for tests: every entry (from the root or any child) lands\n *  in `entries`, with child bindings merged into meta. */\nexport function createCapturingLogger(): { logger: Logger; entries: CapturedLog[] } {\n  const entries: CapturedLog[] = [];\n  const make = (bindings: Record<string, unknown>): Logger => {\n    const record =\n      (level: CapturedLog['level']) => (msg: string, meta?: Record<string, unknown>) => {\n        entries.push({ level, msg, meta: { ...bindings, ...meta } });\n      };\n    return {\n      debug: record('debug'),\n      info: record('info'),\n      warn: record('warn'),\n      error: record('error'),\n      child: (more) => make({ ...bindings, ...more }),\n    };\n  };\n  return { logger: make({}), entries };\n}\n"],"mappings":";;AAMA,MAAa,aAAqB;CAChC,aAAa,CAAC;CACd,YAAY,CAAC;CACb,YAAY,CAAC;CACb,aAAa,CAAC;CACd,aAAa;AACf;;;AAUA,SAAgB,wBAAoE;CAClF,MAAM,UAAyB,CAAC;CAChC,MAAM,QAAQ,aAA8C;EAC1D,MAAM,UACH,WAAiC,KAAa,SAAmC;GAChF,QAAQ,KAAK;IAAE;IAAO;IAAK,MAAM;KAAE,GAAG;KAAU,GAAG;IAAK;GAAE,CAAC;EAC7D;EACF,OAAO;GACL,OAAO,OAAO,OAAO;GACrB,MAAM,OAAO,MAAM;GACnB,MAAM,OAAO,MAAM;GACnB,OAAO,OAAO,OAAO;GACrB,QAAQ,SAAS,KAAK;IAAE,GAAG;IAAU,GAAG;GAAK,CAAC;EAChD;CACF;CACA,OAAO;EAAE,QAAQ,KAAK,CAAC,CAAC;EAAG;CAAQ;AACrC"}

package/dist/shared/mailer.d.ts

@@ -0,0 +1,23 @@
+import { EmailSender } from "../types/ports.js";
+import { EmailTemplateId, EmailTemplateParams, TemplateContext, TemplateRenderer } from "../types/email-templates.js";
+import "./ports.js";
+//#region src/shared/mailer.d.ts
+/** Resolves the recipient/content details a template needs when the
+ *  triggering event carries only row ids. Wired by the app layer. */
+interface MailerLookups {
+  orgUserEmail(orgId: string, orgUserId: string): Promise<string | null>;
+  contentInfo(orgId: string, contentId: string): Promise<{
+    id: string;
+    title: string;
+  } | null>;
+}
+declare class Mailer {
+  private readonly templates;
+  private readonly email;
+  private readonly ctx;
+  constructor(templates: TemplateRenderer, email: EmailSender, ctx: TemplateContext);
+  send<K extends EmailTemplateId>(to: string, id: K, params: EmailTemplateParams[K], ctx?: Partial<TemplateContext>): Promise<void>;
+}
+//#endregion
+export { Mailer, MailerLookups };
+//# sourceMappingURL=mailer.d.ts.map

package/dist/shared/mailer.js

@@ -0,0 +1,27 @@
+//#region src/shared/mailer.ts
+var Mailer = class {
+	templates;
+	email;
+	ctx;
+	constructor(templates, email, ctx) {
+		this.templates = templates;
+		this.email = email;
+		this.ctx = ctx;
+	}
+	async send(to, id, params, ctx) {
+		const content = await this.templates.render(id, {
+			...this.ctx,
+			...ctx
+		}, params);
+		await this.email.send({
+			to,
+			subject: content.subject,
+			text: content.text,
+			html: content.html
+		});
+	}
+};
+//#endregion
+export { Mailer };
+
+//# sourceMappingURL=mailer.js.map

package/dist/shared/mailer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mailer.js","names":[],"sources":["../../src/shared/mailer.ts"],"sourcesContent":["// Composes a TemplateRenderer with an EmailSender: callers name a template,\n// the mailer resolves content and hands it to the transport.\nimport type {\n  EmailSender,\n  EmailTemplateId,\n  EmailTemplateParams,\n  TemplateContext,\n  TemplateRenderer,\n} from './ports.js';\n\n/** Resolves the recipient/content details a template needs when the\n *  triggering event carries only row ids. Wired by the app layer. */\nexport interface MailerLookups {\n  orgUserEmail(orgId: string, orgUserId: string): Promise<string | null>;\n  contentInfo(orgId: string, contentId: string): Promise<{ id: string; title: string } | null>;\n}\n\nexport class Mailer {\n  constructor(\n    private readonly templates: TemplateRenderer,\n    private readonly email: EmailSender,\n    private readonly ctx: TemplateContext,\n  ) {}\n\n  async send<K extends EmailTemplateId>(\n    to: string,\n    id: K,\n    params: EmailTemplateParams[K],\n    ctx?: Partial<TemplateContext>,\n  ): Promise<void> {\n    const content = await this.templates.render(id, { ...this.ctx, ...ctx }, params);\n    await this.email.send({ to, subject: content.subject, text: content.text, html: content.html });\n  }\n\n\n}\n"],"mappings":";AAiBA,IAAa,SAAb,MAAoB;CAEC;CACA;CACA;CAHnB,YACE,WACA,OACA,KACA;EAHiB,KAAA,YAAA;EACA,KAAA,QAAA;EACA,KAAA,MAAA;CAChB;CAEH,MAAM,KACJ,IACA,IACA,QACA,KACe;EACf,MAAM,UAAU,MAAM,KAAK,UAAU,OAAO,IAAI;GAAE,GAAG,KAAK;GAAK,GAAG;EAAI,GAAG,MAAM;EAC/E,MAAM,KAAK,MAAM,KAAK;GAAE;GAAI,SAAS,QAAQ;GAAS,MAAM,QAAQ;GAAM,MAAM,QAAQ;EAAK,CAAC;CAChG;AAGF"}

package/dist/shared/ports.d.ts

@@ -0,0 +1,62 @@
+import { DomainEvent, NewDomainEvent } from "../types/shared.js";
+import { EventDefinition } from "../types/events.js";
+import { EmailMessage, EmailSender, Logger, ObjectStorage, PresignDownloadInput, PresignedUpload, StoredObjectInfo } from "../types/ports.js";
+import { EmailContent, EmailTemplateId, EmailTemplateParams, TemplateContext, TemplateRenderer } from "../types/email-templates.js";
+import "../types/index.js";
+import { EventOf, EventOfValues, InvalidDomainEventError, RuntimeEventDefinition, defineEvent, eventIdSchema, eventJsonValueSchema, eventMetadataSchema } from "./events.js";
+//#region src/shared/ports.d.ts
+interface Clock {
+  now(): Date;
+}
+interface EventBus {
+  publish(event: DomainEvent): Promise<void>;
+  subscribe<E extends DomainEvent>(definition: EventDefinition<E>, handler: (event: E) => Promise<void>): void;
+  subscribe(type: string, handler: (event: DomainEvent) => Promise<void>): void;
+  subscribeAll(handler: (event: DomainEvent) => Promise<void>): void;
+}
+/** Appends domain events to the transactional outbox. A tx-bound member of a
+ *  UnitOfWork scope, so the append shares that transaction — the event
+ *  becomes visible to the relay only when the surrounding write commits. */
+interface OutboxAppender {
+  append<E extends NewDomainEvent>(events: E[]): Promise<void>;
+}
+/** Runs a callback atomically: every port in the scope executes in one
+ *  database transaction; a thrown error rolls all of it back. */
+interface UnitOfWork<Scope> {
+  run<T>(fn: (scope: Scope) => Promise<T>): Promise<T>;
+}
+interface OutboxMessage {
+  id: string;
+  /** Prior failed dispatch count — input to the relay's backoff. */
+  attempts: number;
+  payload: DomainEvent;
+}
+interface OutboxStore {
+  /** Due, unexhausted, unprocessed messages in id order; claims them for this reader. */
+  fetchBatch(limit: number): Promise<OutboxMessage[]>;
+  /** Published to the EventBus — stamps processedAt. */
+  markProcessed(id: string): Promise<void>;
+  /** Dispatch failed — increments attempts, records the error, schedules the retry. */
+  markFailed(id: string, error: string, nextAttemptAt: Date): Promise<void>;
+}
+/** The relay mechanism — how committed outbox rows become dispatched events.
+ *  Swappable: same-process poller today; LISTEN/NOTIFY or an external worker
+ *  later, without touching producers or subscribers. */
+interface OutboxRelay {
+  start(): void;
+  /** Graceful: resolves after the in-flight batch finishes. Safe if never started. */
+  stop(): Promise<void>;
+}
+interface CredentialStore {
+  /** Encrypt and persist an org's secrets. Returns the ref the domain stores. */
+  store(orgId: string, secrets: Record<string, unknown>): Promise<string>;
+  /** Decrypt secrets at point of use, or null if the ref doesn't exist in the org. */
+  reveal(orgId: string, ref: string): Promise<Record<string, unknown> | null>;
+  /** Replace stored secrets in place (e.g. reconnect / token refresh). */
+  update(orgId: string, ref: string, secrets: Record<string, unknown>): Promise<void>;
+  /** Permanently delete stored secrets (e.g. disconnect). */
+  destroy(orgId: string, ref: string): Promise<void>;
+}
+//#endregion
+export { Clock, CredentialStore, type DomainEvent, type EmailContent, type EmailMessage, type EmailSender, type EmailTemplateId, type EmailTemplateParams, EventBus, type EventDefinition, type EventOf, type EventOfValues, InvalidDomainEventError, type Logger, type NewDomainEvent, type ObjectStorage, OutboxAppender, OutboxMessage, OutboxRelay, OutboxStore, type PresignDownloadInput, type PresignedUpload, type RuntimeEventDefinition, type StoredObjectInfo, type TemplateContext, type TemplateRenderer, UnitOfWork, defineEvent, eventIdSchema, eventJsonValueSchema, eventMetadataSchema };
+//# sourceMappingURL=ports.d.ts.map

package/dist/shared/ports.js

@@ -0,0 +1,2 @@
+import { InvalidDomainEventError, defineEvent, eventIdSchema, eventJsonValueSchema, eventMetadataSchema } from "./events.js";
+export { InvalidDomainEventError, defineEvent, eventIdSchema, eventJsonValueSchema, eventMetadataSchema };

package/dist/shared/settings.d.ts

@@ -0,0 +1,25 @@
+//#region src/shared/settings.d.ts
+interface SettingsRecord {
+  namespace: string;
+  scopeId: string;
+  value?: Record<string, unknown>;
+}
+declare enum SettingsNamespace {
+  content = "content"
+}
+interface SettingsRepository {
+  /** Rows for the given scopes, optionally narrowed to one namespace. */
+  find(orgId: string, scopeId: string, namespace?: string): Promise<SettingsRecord[]>;
+  /** Deep-merges the patch into the row's value, inserting when absent. Nested
+   *  objects merge key by key; arrays and scalars are replaced outright. */
+  patch(orgId: string, namespace: string, scopeId: string, value: unknown): Promise<SettingsRecord>;
+}
+declare class SettingsService {
+  private readonly repo;
+  constructor(repo: SettingsRepository);
+  get<T>(orgId: string, namespace: string, scopeId: string, defaultIfNull?: T): Promise<T | undefined>;
+  patch<T>(orgId: string, namespace: string, scopeId: string, value: unknown): Promise<T>;
+}
+//#endregion
+export { SettingsNamespace, SettingsRecord, SettingsRepository, SettingsService };
+//# sourceMappingURL=settings.d.ts.map

package/dist/shared/settings.js

@@ -0,0 +1,21 @@
+//#region src/shared/settings.ts
+let SettingsNamespace = /* @__PURE__ */ function(SettingsNamespace) {
+	SettingsNamespace["content"] = "content";
+	return SettingsNamespace;
+}({});
+var SettingsService = class {
+	repo;
+	constructor(repo) {
+		this.repo = repo;
+	}
+	async get(orgId, namespace, scopeId, defaultIfNull) {
+		return (await this.repo.find(orgId, scopeId, namespace))[0]?.value ?? defaultIfNull;
+	}
+	async patch(orgId, namespace, scopeId, value) {
+		return (await this.repo.patch(orgId, namespace, scopeId, value)).value;
+	}
+};
+//#endregion
+export { SettingsNamespace, SettingsService };
+
+//# sourceMappingURL=settings.js.map

package/dist/shared/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","names":[],"sources":["../../src/shared/settings.ts"],"sourcesContent":["// Cross-cutting settings: storage, scoping and resolution for every domain's\n// configuration. Not a bounded context: it is a leaf every context may import, and it imports\n// no context.\n\nexport interface SettingsRecord {\n  namespace: string;\n  scopeId: string;\n  value?: Record<string,unknown>;\n}\n\nexport enum SettingsNamespace {\n  content = 'content',\n}\n\nexport interface SettingsRepository {\n  /** Rows for the given scopes, optionally narrowed to one namespace. */\n  find(orgId: string, scopeId: string, namespace?: string): Promise<SettingsRecord[]>;\n  /** Deep-merges the patch into the row's value, inserting when absent. Nested\n   *  objects merge key by key; arrays and scalars are replaced outright. */\n  patch(orgId: string, namespace: string, scopeId: string, value: unknown): Promise<SettingsRecord>;\n}\n\nexport class SettingsService {\n  constructor(private readonly repo: SettingsRepository) {}\n\n  async get<T>(\n    orgId: string,\n    namespace: string,\n    scopeId: string,\n    defaultIfNull?: T,\n  ): Promise<T | undefined> {\n    const rows = await this.repo.find(orgId, scopeId, namespace);\n    return (rows[0]?.value as T) ?? defaultIfNull;\n  }\n\n  async patch<T>(orgId: string, namespace: string, scopeId: string, value: unknown): Promise<T> {\n    const row = await this.repo.patch(orgId, namespace, scopeId, value);\n    return row.value as T;\n  }\n}\n"],"mappings":";AAUA,IAAY,oBAAL,yBAAA,mBAAA;CACL,kBAAA,aAAA;;AACF,EAAA,CAAA,CAAA;AAUA,IAAa,kBAAb,MAA6B;CACE;CAA7B,YAAY,MAA2C;EAA1B,KAAA,OAAA;CAA2B;CAExD,MAAM,IACJ,OACA,WACA,SACA,eACwB;EAExB,QAAQ,MADW,KAAK,KAAK,KAAK,OAAO,SAAS,SAAS,EAAA,CAC9C,EAAE,EAAE,SAAe;CAClC;CAEA,MAAM,MAAS,OAAe,WAAmB,SAAiB,OAA4B;EAE5F,QAAO,MADW,KAAK,KAAK,MAAM,OAAO,WAAW,SAAS,KAAK,EAAA,CACvD;CACb;AACF"}

package/dist/types/assets.d.ts

@@ -0,0 +1,2 @@
+import { Asset, AssetKind, AssetStatus, AssetsQuery, DownloadTicket, RequestUploadInput, UploadTicket } from "./schemas/assets.js";
+export type { Asset, AssetKind, AssetStatus, AssetsQuery, DownloadTicket, RequestUploadInput, UploadTicket };

package/dist/types/assets.js

@@ -0,0 +1 @@
+export {};