@manablox/db 0.1.0 → 0.3.0

package/dist/testing.js

@@ -0,0 +1,217 @@
+import { _ as applyBootstrapSql, g as createDatabase, t as createRepositories } from "./repositories-DYjzuuF6.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/0005_menus.sql

@@ -0,0 +1,44 @@
+CREATE TABLE "menu_items" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"menu_id" uuid NOT NULL,
+	"parent_id" uuid,
+	"position" integer DEFAULT 0 NOT NULL,
+	"localization_id" uuid,
+	"label" text,
+	"url" text
+);
+--> statement-breakpoint
+CREATE TABLE "menus" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"space_id" uuid NOT NULL,
+	"name" text NOT NULL,
+	"machine_name" text NOT NULL,
+	"description" text,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+	CONSTRAINT "menus_space_machine_name_key" UNIQUE("space_id","machine_name")
+);
+--> statement-breakpoint
+ALTER TABLE "menu_items" ADD CONSTRAINT "menu_items_menu_id_menus_id_fk" FOREIGN KEY ("menu_id") REFERENCES "public"."menus"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "menu_items" ADD CONSTRAINT "menu_items_parent_id_menu_items_id_fk" FOREIGN KEY ("parent_id") REFERENCES "public"."menu_items"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "menus" ADD CONSTRAINT "menus_space_id_spaces_id_fk" FOREIGN KEY ("space_id") REFERENCES "public"."spaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "menu_items_menu_idx" ON "menu_items" USING btree ("menu_id","parent_id","position");--> statement-breakpoint
+CREATE INDEX "menu_items_localization_idx" ON "menu_items" USING btree ("localization_id");--> statement-breakpoint
+-- Every document that was flagged "show in menu" becomes an entry of a "Main" menu in
+-- its space, one entry per document (all translations share it), nested the way the
+-- documents nest in the tree. Entry ids equal the documents' localization ids for the
+-- duration of the migration so parents can be linked in one pass.
+INSERT INTO "menus" ("space_id", "name", "machine_name", "description")
+SELECT "space_id", 'Main', 'main', 'Created from the former "show in menu" flag.'
+FROM "contents" WHERE "visible_in_menu" GROUP BY "space_id";--> statement-breakpoint
+INSERT INTO "menu_items" ("id", "menu_id", "parent_id", "position", "localization_id")
+SELECT DISTINCT ON (c."localization_id") c."localization_id", m."id", NULL, c."position", c."localization_id"
+FROM "contents" c JOIN "menus" m ON m."space_id" = c."space_id" AND m."machine_name" = 'main'
+WHERE c."visible_in_menu"
+ORDER BY c."localization_id", c."locale";--> statement-breakpoint
+UPDATE "menu_items" mi SET "parent_id" = p."localization_id"
+FROM "contents" c JOIN "contents" p ON p."id" = c."parent_id"
+WHERE mi."id" = c."localization_id"
+  AND EXISTS (SELECT 1 FROM "menu_items" x WHERE x."id" = p."localization_id" AND x."menu_id" = mi."menu_id");--> statement-breakpoint
+ALTER TABLE "contents" DROP COLUMN "visible_in_menu";--> statement-breakpoint
+ALTER TABLE "published_contents" DROP COLUMN "visible_in_menu";

package/migrations/0006_roles.sql

@@ -0,0 +1,13 @@
+CREATE TABLE "roles" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"space_id" uuid NOT NULL,
+	"name" text NOT NULL,
+	"machine_name" text NOT NULL,
+	"description" text,
+	"permissions" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "roles" ADD CONSTRAINT "roles_space_id_spaces_id_fk" FOREIGN KEY ("space_id") REFERENCES "public"."spaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE UNIQUE INDEX "roles_space_machine_name_key" ON "roles" USING btree ("space_id","machine_name");

package/migrations/0007_apikey-permissions.sql

@@ -0,0 +1,4 @@
+-- The column was declared by better-auth's key schema and never written; it now holds
+-- the key's grants as a JSON array. Anything that is not one becomes null.
+ALTER TABLE "apikeys" ALTER COLUMN "permissions" SET DATA TYPE jsonb
+  USING (CASE WHEN "permissions" ~ '^\s*\[' THEN "permissions"::jsonb ELSE NULL END);

package/migrations/0008_workflows.sql

@@ -0,0 +1,49 @@
+CREATE TABLE "push_subscriptions" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" uuid NOT NULL,
+	"endpoint" text NOT NULL,
+	"keys" jsonb NOT NULL,
+	"user_agent" text,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"last_used_at" timestamp with time zone,
+	CONSTRAINT "push_subscriptions_endpoint_key" UNIQUE("endpoint")
+);
+--> statement-breakpoint
+CREATE TABLE "workflow_runs" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"workflow_id" uuid NOT NULL,
+	"space_id" uuid NOT NULL,
+	"trigger" text NOT NULL,
+	"status" text DEFAULT 'queued' NOT NULL,
+	"context" jsonb NOT NULL,
+	"cursor" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"log" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"error" text,
+	"resume_at" timestamp with time zone,
+	"started_at" timestamp with time zone,
+	"finished_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "workflows" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"space_id" uuid NOT NULL,
+	"name" text NOT NULL,
+	"description" text,
+	"enabled" boolean DEFAULT false NOT NULL,
+	"trigger" jsonb NOT NULL,
+	"steps" jsonb DEFAULT '[]'::jsonb NOT NULL,
+	"last_scheduled_at" timestamp with time zone,
+	"last_run_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "push_subscriptions" ADD CONSTRAINT "push_subscriptions_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_runs" ADD CONSTRAINT "workflow_runs_workflow_id_workflows_id_fk" FOREIGN KEY ("workflow_id") REFERENCES "public"."workflows"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflow_runs" ADD CONSTRAINT "workflow_runs_space_id_spaces_id_fk" FOREIGN KEY ("space_id") REFERENCES "public"."spaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "workflows" ADD CONSTRAINT "workflows_space_id_spaces_id_fk" FOREIGN KEY ("space_id") REFERENCES "public"."spaces"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "push_subscriptions_user_idx" ON "push_subscriptions" USING btree ("user_id");--> statement-breakpoint
+CREATE INDEX "workflow_runs_workflow_idx" ON "workflow_runs" USING btree ("workflow_id","created_at");--> statement-breakpoint
+CREATE INDEX "workflow_runs_resume_idx" ON "workflow_runs" USING btree ("status","resume_at");--> statement-breakpoint
+CREATE INDEX "workflows_space_idx" ON "workflows" USING btree ("space_id","enabled");