@manablox/db 0.2.0 → 0.4.0

package/dist/testing.d.ts

@@ -0,0 +1,77 @@
+import { it as DatabaseHandle, t as Repositories } from "./index-BLAkQMJT.js";
+import { ContentTypeDefinition, ContentTypeRegistry } from "@manablox/core";
+//#region src/testing-fixtures.d.ts
+export declare const stringField: import("@manablox/core").FieldTypeDefinition<Record<string, unknown>, string>;
+export declare const numberField: import("@manablox/core").FieldTypeDefinition<Record<string, unknown>, number>;
+export interface RepositoryTestContext {
+  handle: DatabaseHandle;
+  /** Every statement sent to Postgres, so a test can assert what a call cost. */
+  queries: string[];
+  repos: Repositories;
+  registry: ContentTypeRegistry;
+  types: {
+    page: ContentTypeDefinition;
+    folder: ContentTypeDefinition;
+  };
+  spaceId: string;
+  close: () => Promise<void>;
+}
+/** Spins up an isolated database per suite, migrated from the real migration files. */
+export declare function createRepositoryContext(name: string): Promise<RepositoryTestContext>;
+/** Convenience creator so tests read as tree shapes rather than field soup. */
+export declare function makeNode(ctx: RepositoryTestContext, options: {
+  title: string;
+  slug: string;
+  parentId?: string | null;
+  type?: 'page' | 'folder';
+  fields?: Record<string, unknown>;
+}): Promise<{
+  createdAt: Date;
+  createdBy: string | null;
+  fields: Record<string, unknown>;
+  id: string;
+  locale: string;
+  localizationId: string;
+  parentId: string | null;
+  path: string;
+  permalink: string | null;
+  permalinkPath: string;
+  permalinkSegment: string | null;
+  position: number;
+  publishedAt: Date | null;
+  search: string | null;
+  searchText: string;
+  slug: string;
+  spaceId: string;
+  status: import("@manablox/core").ContentStatus;
+  title: string;
+  typeId: string;
+  updatedAt: Date;
+  updatedBy: string | null;
+  version: number;
+}>;
+//#endregion
+//#region src/testing.d.ts
+/**
+ * Only ever connected to in order to `create database`: every test file works in its own
+ * fresh database and drops it again, so this points at a Postgres *server*, not at data
+ * the tests touch. That is why falling back to `DATABASE_URL` is safe — it means the
+ * suite runs wherever the app itself runs (a container, CI, the host) without a second
+ * variable that has to be kept in step. `TEST_DATABASE_URL` still overrides it.
+ */
+export declare const TEST_ADMIN_URL: string;
+export declare function withDatabase(url: string, name: string): string;
+export interface TestDatabase {
+  name: string;
+  url: string;
+  /** Drops the database. Safe to call once every connection to it is closed. */
+  drop: () => Promise<void>;
+}
+/**
+ * A fresh, migrated database for one test suite, cloned from the template.
+ *
+ * `prefix` names the suite in `pg_database`, which is what you grep for when a run was
+ * interrupted and left a database behind.
+ */
+export declare function createTestDatabase(prefix: string): Promise<TestDatabase>;
+//#endregion

package/dist/testing.js

@@ -0,0 +1,217 @@
+import { b as applyBootstrapSql, t as createRepositories, y as createDatabase } from "./repositories-pz4NeWaF.js";
+import postgres from "postgres";
+import { ContentTypeRegistry, FieldTypeRegistry, defineContentType, defineFieldType } from "@manablox/core";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { migrate } from "drizzle-orm/postgres-js/migrator";
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync } from "node:fs";
+//#region src/testing-fixtures.ts
+/**
+* Fixtures for a repository-level test: two plain field types, a `page` and a `folder`
+* content type, a migrated database with one space, and a node maker. Shared through
+* `@manablox/db/testing` so a suite in another package can start from the same world.
+*/
+const anySchema = () => ({ "~standard": {
+	version: 1,
+	vendor: "test",
+	validate: (value) => ({ value })
+} });
+const stringField = defineFieldType({
+	name: "string",
+	label: "Text",
+	settingsSchema: anySchema(),
+	valueSchema: () => anySchema(),
+	defaultValue: () => "",
+	storage: {
+		kind: "jsonb",
+		index: "btree"
+	},
+	filters: [
+		"eq",
+		"neq",
+		"contains",
+		"startsWith",
+		"in",
+		"isNull",
+		"isNotNull"
+	],
+	graphql: { type: {
+		kind: "scalar",
+		name: "String"
+	} },
+	search: (value) => typeof value === "string" ? value : null,
+	admin: { input: "string" }
+});
+const numberField = defineFieldType({
+	name: "number",
+	label: "Number",
+	settingsSchema: anySchema(),
+	valueSchema: () => anySchema(),
+	defaultValue: () => 0,
+	storage: {
+		kind: "jsonb",
+		index: "btree"
+	},
+	filters: [
+		"eq",
+		"lt",
+		"lte",
+		"gt",
+		"gte"
+	],
+	graphql: { type: {
+		kind: "scalar",
+		name: "Float"
+	} },
+	admin: { input: "number" }
+});
+/** Spins up an isolated database per suite, migrated from the real migration files. */
+async function createRepositoryContext(name) {
+	const database = await createTestDatabase(name);
+	const queries = [];
+	const handle = createDatabase({
+		url: database.url,
+		max: 4
+	}, { onQuery: (query) => queries.push(query) });
+	const fieldTypes = new FieldTypeRegistry();
+	fieldTypes.register(stringField);
+	fieldTypes.register(numberField);
+	const page = defineContentType({
+		name: "page",
+		fields: [{
+			name: "body",
+			type: "string"
+		}, {
+			name: "weight",
+			type: "number"
+		}]
+	});
+	const folder = defineContentType({
+		name: "folder",
+		hasSlug: false,
+		fields: [{
+			name: "note",
+			type: "string"
+		}]
+	});
+	const registry = new ContentTypeRegistry(fieldTypes);
+	registry.setAll([page, folder]);
+	registry.validate();
+	const repos = createRepositories(handle.db, registry);
+	const space = await repos.spaces.create({
+		name: "Test",
+		machineName: "test",
+		url: "http://localhost:3002"
+	});
+	return {
+		handle,
+		queries,
+		repos,
+		registry,
+		types: {
+			page,
+			folder
+		},
+		spaceId: space.id,
+		close: async () => {
+			await handle.close();
+			await database.drop();
+		}
+	};
+}
+/** Convenience creator so tests read as tree shapes rather than field soup. */
+async function makeNode(ctx, options) {
+	const type = ctx.types[options.type ?? "page"];
+	const searchText = Object.values(options.fields ?? {}).filter((value) => typeof value === "string").join(" ");
+	return ctx.repos.content.create({
+		searchText,
+		spaceId: ctx.spaceId,
+		typeId: type.id,
+		locale: "en",
+		parentId: options.parentId ?? null,
+		title: options.title,
+		slug: options.slug,
+		fields: options.fields ?? {},
+		hasSlug: type.hasSlug
+	});
+}
+//#endregion
+//#region src/testing.ts
+const MIGRATIONS = resolve(dirname(fileURLToPath(import.meta.url)), "../migrations");
+/**
+* Only ever connected to in order to `create database`: every test file works in its own
+* fresh database and drops it again, so this points at a Postgres *server*, not at data
+* the tests touch. That is why falling back to `DATABASE_URL` is safe — it means the
+* suite runs wherever the app itself runs (a container, CI, the host) without a second
+* variable that has to be kept in step. `TEST_DATABASE_URL` still overrides it.
+*/
+const TEST_ADMIN_URL = process.env.TEST_DATABASE_URL ?? process.env.DATABASE_URL ?? "postgres://manablox:manablox@localhost:5432/manablox";
+/** A fingerprint of the migration files, so a schema change gets a fresh template. */
+function migrationsFingerprint() {
+	const hash = createHash("sha1");
+	for (const file of readdirSync(MIGRATIONS).sort()) if (file.endsWith(".sql")) hash.update(readFileSync(join(MIGRATIONS, file)));
+	return hash.digest("hex").slice(0, 10);
+}
+const TEMPLATE = `manablox_test_template_${migrationsFingerprint()}`;
+/**
+* Makes sure the migrated template exists, once per server.
+*
+* Migrating takes a second or two; `create database … template …` takes milliseconds,
+* so every suite clones the template instead of migrating from scratch. Suites run in
+* parallel across processes, so the check-and-create is serialised on a session-level
+* advisory lock — the second process finds the template already there.
+*/
+async function ensureTemplate(admin) {
+	await admin.unsafe(`select pg_advisory_lock(hashtext('${TEMPLATE}'))`);
+	try {
+		const [row] = await admin.unsafe(`select 1 as found from pg_database where datname = '${TEMPLATE}'`);
+		if (row) return;
+		await admin.unsafe(`create database "${TEMPLATE}"`);
+		const handle = createDatabase({
+			url: withDatabase(TEST_ADMIN_URL, TEMPLATE),
+			max: 1
+		});
+		try {
+			await applyBootstrapSql(handle.sql);
+			await migrate(handle.db, { migrationsFolder: MIGRATIONS });
+		} finally {
+			await handle.close();
+		}
+	} finally {
+		await admin.unsafe(`select pg_advisory_unlock(hashtext('${TEMPLATE}'))`);
+	}
+}
+function withDatabase(url, name) {
+	return url.replace(/\/[^/?]*(\?.*)?$/, `/${name}$1`);
+}
+/**
+* A fresh, migrated database for one test suite, cloned from the template.
+*
+* `prefix` names the suite in `pg_database`, which is what you grep for when a run was
+* interrupted and left a database behind.
+*/
+async function createTestDatabase(prefix) {
+	const name = `manablox_test_${prefix}_${Date.now().toString(36)}_${process.pid.toString(36)}`;
+	const admin = postgres(TEST_ADMIN_URL, { max: 1 });
+	try {
+		await ensureTemplate(admin);
+		await admin.unsafe(`create database "${name}" template "${TEMPLATE}"`);
+	} finally {
+		await admin.end();
+	}
+	return {
+		name,
+		url: withDatabase(TEST_ADMIN_URL, name),
+		drop: async () => {
+			const cleanup = postgres(TEST_ADMIN_URL, { max: 1 });
+			try {
+				await cleanup.unsafe(`drop database if exists "${name}" with (force)`);
+			} finally {
+				await cleanup.end();
+			}
+		}
+	};
+}
+//#endregion
+export { TEST_ADMIN_URL, createRepositoryContext, createTestDatabase, makeNode, numberField, stringField, withDatabase };

package/migrations/0009_audit-log.sql

@@ -0,0 +1,40 @@
+CREATE TABLE "audit_entries" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"seq" bigserial NOT NULL,
+	"at" timestamp with time zone DEFAULT now() NOT NULL,
+	"space_id" uuid,
+	"actor_kind" text NOT NULL,
+	"actor_id" text,
+	"actor_label" text NOT NULL,
+	"actor_detail" jsonb,
+	"action" text NOT NULL,
+	"target_kind" text NOT NULL,
+	"target_id" text,
+	"target_label" text,
+	"changes" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"meta" jsonb,
+	"prev_hash" text,
+	"hash" text NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX "audit_entries_seq_idx" ON "audit_entries" USING btree ("seq");--> statement-breakpoint
+CREATE INDEX "audit_entries_space_at_idx" ON "audit_entries" USING btree ("space_id","at");--> statement-breakpoint
+CREATE INDEX "audit_entries_target_idx" ON "audit_entries" USING btree ("target_kind","target_id");--> statement-breakpoint
+CREATE INDEX "audit_entries_actor_idx" ON "audit_entries" USING btree ("actor_kind","actor_id");--> statement-breakpoint
+CREATE INDEX "audit_entries_action_idx" ON "audit_entries" USING btree ("action");--> statement-breakpoint
+-- The log is append-only. Postgres has no "insert-only" grant short of a second role,
+-- so a trigger refuses every update and delete instead; dropping it is a deliberate,
+-- visible act rather than a stray statement. Not tracked by drizzle-kit: `pnpm
+-- db:generate` neither sees nor removes it.
+CREATE FUNCTION audit_entries_immutable() RETURNS trigger AS $$
+BEGIN
+  RAISE EXCEPTION 'audit_entries is append-only: % refused', TG_OP
+    USING ERRCODE = 'insufficient_privilege';
+END;
+$$ LANGUAGE plpgsql;--> statement-breakpoint
+CREATE TRIGGER audit_entries_immutable
+  BEFORE UPDATE OR DELETE ON "audit_entries"
+  FOR EACH ROW EXECUTE FUNCTION audit_entries_immutable();--> statement-breakpoint
+CREATE TRIGGER audit_entries_no_truncate
+  BEFORE TRUNCATE ON "audit_entries"
+  FOR EACH STATEMENT EXECUTE FUNCTION audit_entries_immutable();

package/migrations/0010_notifications-approvals.sql

@@ -0,0 +1,45 @@
+CREATE TABLE "content_approvals" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"space_id" uuid NOT NULL,
+	"content_id" uuid NOT NULL,
+	"type_id" uuid NOT NULL,
+	"status" text DEFAULT 'pending' NOT NULL,
+	"requested_by" uuid,
+	"requested_by_label" text DEFAULT '' NOT NULL,
+	"request_note" text,
+	"content_version" integer,
+	"requested_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"decided_by" uuid,
+	"decided_by_label" text,
+	"decision_note" text,
+	"decided_at" timestamp with time zone
+);
+--> statement-breakpoint
+CREATE TABLE "notifications" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"space_id" uuid,
+	"kind" text NOT NULL,
+	"title" text NOT NULL,
+	"body" text DEFAULT '' NOT NULL,
+	"url" text,
+	"target_kind" text,
+	"target_id" text,
+	"actor_id" text,
+	"actor_label" text,
+	"meta" jsonb,
+	"read_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "notification_preferences" jsonb DEFAULT '{}'::jsonb NOT NULL;--> statement-breakpoint
+ALTER TABLE "content_types" ADD COLUMN "requires_approval" boolean DEFAULT false NOT NULL;--> statement-breakpoint
+ALTER TABLE "content_approvals" ADD CONSTRAINT "content_approvals_space_id_spaces_id_fk" FOREIGN KEY ("space_id") REFERENCES "public"."spaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "content_approvals" ADD CONSTRAINT "content_approvals_content_id_contents_id_fk" FOREIGN KEY ("content_id") REFERENCES "public"."contents"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "notifications" ADD CONSTRAINT "notifications_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "notifications" ADD CONSTRAINT "notifications_space_id_spaces_id_fk" FOREIGN KEY ("space_id") REFERENCES "public"."spaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "content_approvals_content_idx" ON "content_approvals" USING btree ("content_id","requested_at");--> statement-breakpoint
+CREATE INDEX "content_approvals_space_status_idx" ON "content_approvals" USING btree ("space_id","status","requested_at");--> statement-breakpoint
+CREATE INDEX "notifications_user_created_idx" ON "notifications" USING btree ("user_id","created_at");--> statement-breakpoint
+CREATE INDEX "notifications_user_unread_idx" ON "notifications" USING btree ("user_id","read_at");--> statement-breakpoint
+CREATE INDEX "notifications_target_idx" ON "notifications" USING btree ("target_kind","target_id");