@manablox/db 0.2.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/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@manablox/db",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./schema": {
-      "types": "./src/schema/index.ts",
-      "default": "./src/schema/index.ts"
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.js"
     },
     "./testing": {
-      "types": "./src/testing.ts",
-      "default": "./src/testing.ts"
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
     }
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@manablox/core": "0.2.0",
+    "@manablox/core": "0.3.0",
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.9"
   },
@@ -28,11 +28,19 @@
     "@types/node": "^26.4.1",
     "drizzle-kit": "^0.31.10",
     "testcontainers": "^12.1.0",
+    "tsdown": "^0.23.0",
     "tsx": "^4.20.7",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "migrations",
+    "README.md"
+  ],
   "scripts": {
+    "build": "tsdown",
     "generate": "drizzle-kit generate",
     "migrate": "tsx src/cli/migrate.ts",
     "typecheck": "tsc --noEmit",

package/drizzle.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-  schema: './src/schema/index.ts',
-  out: './migrations',
-  dialect: 'postgresql',
-  dbCredentials: {
-    url: process.env.DATABASE_URL ?? 'postgres://manablox:manablox@localhost:5432/manablox',
-  },
-  casing: 'snake_case',
-});

package/src/bootstrap.ts

@@ -1,13 +0,0 @@
-import type { Sql } from './client.js';
-
-/**
- * Extensions the schema depends on. Run before the generated migrations, which
- * reference `ltree` columns and `pg_trgm` operator classes.
- */
-export async function applyBootstrapSql(sql: Sql): Promise<void> {
-  await sql.unsafe(`
-    create extension if not exists "ltree";
-    create extension if not exists "pg_trgm";
-    create extension if not exists "btree_gin";
-  `);
-}

package/src/cli/create-db.ts

@@ -1,30 +0,0 @@
-import postgres from 'postgres';
-import { withDatabase } from '../testing.js';
-
-/**
- * Creates the database `DATABASE_URL` names, on the server it names, if it does not
- * exist — `--fresh` drops it first. For throwaway databases (the end-to-end run) where
- * nothing else provisions them.
- */
-const url = process.env.DATABASE_URL;
-if (!url) {
-  console.error('DATABASE_URL is required');
-  process.exit(1);
-}
-
-const name = new URL(url).pathname.replace(/^\//, '');
-const fresh = process.argv.includes('--fresh');
-const admin = postgres(withDatabase(url, 'postgres'), { max: 1 });
-
-try {
-  if (fresh) await admin.unsafe(`drop database if exists "${name}" with (force)`);
-  const [row] = await admin.unsafe(`select 1 as found from pg_database where datname = '${name}'`);
-  if (!row) {
-    await admin.unsafe(`create database "${name}"`);
-    console.info(`created database ${name}`);
-  } else {
-    console.info(`database ${name} exists`);
-  }
-} finally {
-  await admin.end();
-}

package/src/cli/migrate.ts

@@ -1,17 +0,0 @@
-import { createDatabase } from '../client.js';
-import { runMigrations } from '../migrate.js';
-
-const url = process.env.DATABASE_URL;
-if (!url) {
-  console.error('DATABASE_URL is required');
-  process.exit(1);
-}
-
-const handle = createDatabase({ url, max: 1 });
-
-try {
-  await runMigrations(handle);
-  console.info('migrations applied');
-} finally {
-  await handle.close();
-}

package/src/client.ts

@@ -1,44 +0,0 @@
-import type { DatabaseConfig } from '@manablox/core';
-import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
-import * as schema from './schema/index.js';
-
-export type Database = PostgresJsDatabase<typeof schema>;
-/** What `db.transaction((tx) => …)` hands its callback. */
-export type Transaction = Parameters<Parameters<Database['transaction']>[0]>[0];
-/**
- * Anything a query can run on. Repository internals take this so the same helper serves
- * a call inside a transaction and one outside it, without casting `tx` to `Database`.
- */
-export type Executor = Database | Transaction;
-export type Sql = ReturnType<typeof postgres>;
-
-export interface DatabaseHandle {
-  db: Database;
-  sql: Sql;
-  close: () => Promise<void>;
-}
-
-export interface DatabaseOptions {
-  /** Called once per statement sent to Postgres. Used by tests to assert query counts. */
-  onQuery?: (query: string) => void;
-}
-
-export function createDatabase(
-  config: DatabaseConfig,
-  options: DatabaseOptions = {},
-): DatabaseHandle {
-  const sql = postgres(config.url, {
-    max: config.max ?? 10,
-    ...(options.onQuery ? { debug: (_c: number, query: string) => options.onQuery?.(query) } : {}),
-    ...(config.ssl ? { ssl: 'require' as const } : {}),
-    // `ltree` and `tsvector` have no client-side parser, so postgres.js returns them as
-    // strings — which is exactly what the schema declares. Do not pass `types: {}` here:
-    // it replaces the built-in serialisers wholesale and Date parameters stop working.
-    onnotice: () => {},
-  });
-
-  const db = drizzle(sql, { schema, casing: 'snake_case' });
-
-  return { db, sql, close: () => sql.end({ timeout: 5 }) };
-}

package/src/columns.ts

@@ -1,39 +0,0 @@
-import { customType } from 'drizzle-orm/pg-core';
-
-/**
- * `ltree` — the materialised ancestor path of a content node. A subtree move is one
- * `UPDATE ... SET path = :newParent || subpath(path, nlevel(:oldParent))`.
- */
-export const ltree = customType<{ data: string; driverData: string }>({
-  dataType: () => 'ltree',
-});
-
-/** `tsvector` — generated from `title` + `search_text`, never written directly. */
-export const tsvector = customType<{ data: string; driverData: string }>({
-  dataType: () => 'tsvector',
-});
-
-/**
- * ltree labels accept only `[A-Za-z0-9_]`, so UUID hyphens are swapped for underscores.
- * The transform is total and reversible.
- */
-export const idToLabel = (id: string): string => id.replaceAll('-', '_');
-export const labelToId = (label: string): string => {
-  const hex = label.replaceAll('_', '');
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20, 32),
-  ].join('-');
-};
-
-/** Builds the path of a node from its ancestors' ids (root first) plus its own. */
-export const buildPath = (ancestorIds: string[], selfId: string): string =>
-  [...ancestorIds, selfId].map(idToLabel).join('.');
-
-/** Splits a stored path back into ids, root first, self last. */
-export const parsePath = (path: string): string[] => path.split('.').filter(Boolean).map(labelToId);
-
-export const pathDepth = (path: string): number => (path ? path.split('.').length : 0);

package/src/errors.ts

@@ -1,50 +0,0 @@
-import { type ErrorDetail, type ErrorKey, ManabloxError } from '@manablox/core';
-
-/**
- * Postgres reports a unique-constraint violation as SQLSTATE `23505` with the constraint
- * name in the message. Drizzle wraps the driver error, so the code and the message sit on
- * `cause`, while the outer message is only ever "Failed query: insert into …".
- */
-export function isUniqueViolation(error: unknown, constraint: string): boolean {
-  const cause = (error as { cause?: { code?: string; message?: string } })?.cause;
-  const code = (error as { code?: string })?.code ?? cause?.code;
-  const detail = `${cause?.message ?? ''} ${(error as { message?: string })?.message ?? ''}`;
-  return code === '23505' && detail.includes(constraint);
-}
-
-export interface UniqueViolationMapping {
-  /** The constraint name, or a distinctive part of it. */
-  constraint: string;
-  /** The detail reported for the field, e.g. `content.slug.duplicate`. */
-  key: ErrorKey;
-  path?: (string | number)[];
-  params?: Record<string, unknown>;
-  /** The error's own key. */
-  errorKey: ErrorKey;
-}
-
-/**
- * Turns a unique violation on one constraint into the validation error the client would
- * have received had the check run before the write, and rethrows anything else untouched.
- * Use as `.catch((error) => rethrowUniqueViolation(error, { … }))`.
- */
-export function rethrowUniqueViolation(error: unknown, mapping: UniqueViolationMapping): never {
-  if (!isUniqueViolation(error, mapping.constraint)) throw error;
-
-  const detail: ErrorDetail = {
-    key: mapping.key,
-    ...(mapping.path ? { path: mapping.path } : {}),
-    ...(mapping.params ? { params: mapping.params } : {}),
-  };
-  throw ManabloxError.validation([detail], mapping.errorKey);
-}
-
-/**
- * A preset for one constraint: `const taken = uniqueViolation({ … })` once beside the
- * service, then `.catch(taken({ machineName }))` on every write that can trip it. The
- * params are the only part that differs per call, so they are the only argument left.
- */
-export function uniqueViolation(preset: Omit<UniqueViolationMapping, 'params'>) {
-  return (params: Record<string, unknown>) => (error: unknown) =>
-    rethrowUniqueViolation(error, { ...preset, params });
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-export * from './bootstrap.js';
-export * from './client.js';
-export * from './columns.js';
-export * from './errors.js';
-export * from './migrate.js';
-export * from './pagination.js';
-export * from './query.js';
-export * from './repositories/asset.js';
-export * from './repositories/asset-usage.js';
-export * from './repositories/content.js';
-export * from './repositories/content-type.js';
-export * from './repositories/index.js';
-export * from './repositories/menu.js';
-export * from './repositories/space.js';
-export * from './repositories/user.js';
-export * from './repositories/webhook.js';
-export * from './repositories/workflow.js';
-export * as schema from './schema/index.js';
-export * from './schema/index.js';

package/src/migrate.ts

@@ -1,21 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { migrate } from 'drizzle-orm/postgres-js/migrator';
-import { applyBootstrapSql } from './bootstrap.js';
-import type { DatabaseHandle } from './client.js';
-
-/** The SQL files shipped with this package, next to `src/`. */
-export const MIGRATIONS_FOLDER = resolve(dirname(fileURLToPath(import.meta.url)), '../migrations');
-
-/**
- * Brings a database up to the schema this version of the package expects.
- *
- * The same call the compose stack's `migrate` service and the `manablox migrate` CLI
- * make, so an instance run from a dependency and one run from the repository apply the
- * same files in the same order. Idempotent: drizzle records what it has applied.
- */
-export async function runMigrations(handle: DatabaseHandle): Promise<void> {
-  // Extensions must exist before the generated migrations reference ltree columns.
-  await applyBootstrapSql(handle.sql);
-  await migrate(handle.db, { migrationsFolder: MIGRATIONS_FOLDER });
-}

package/src/pagination.ts

@@ -1,52 +0,0 @@
-import { getTableColumns, type SQL, sql } from 'drizzle-orm';
-import type { PgColumn, PgTable } from 'drizzle-orm/pg-core';
-import type { Executor } from './client.js';
-import type { Pagination } from './query.js';
-
-export interface Paginated<T> {
-  items: T[];
-  total: number;
-  limit: number;
-  offset: number;
-}
-
-/**
- * One page of a table plus the total, in one round trip: a window `count(*) over ()`
- * rides along with the rows. A page past the end comes back empty and so carries no
- * count; only then is the total asked for separately, so a caller paging by `total`
- * still learns the true size.
- */
-export async function paginate<TTable extends PgTable>(
-  db: Executor,
-  table: TTable,
-  options: {
-    where?: SQL | undefined;
-    orderBy: SQL | PgColumn | (SQL | PgColumn)[];
-    pagination: Pagination;
-  },
-): Promise<Paginated<TTable['$inferSelect']>> {
-  const orderBy = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
-  const rows = (await db
-    .select({ ...getTableColumns(table), total: sql<number>`count(*) over ()::int` })
-    .from(table as PgTable)
-    .where(options.where)
-    .orderBy(...orderBy)
-    .limit(options.pagination.limit)
-    .offset(options.pagination.offset)) as Array<TTable['$inferSelect'] & { total: number }>;
-
-  let total = rows[0]?.total ?? 0;
-  if (rows.length === 0 && options.pagination.offset > 0) {
-    const counted = await db
-      .select({ count: sql<number>`count(*)::int` })
-      .from(table as PgTable)
-      .where(options.where);
-    total = counted[0]?.count ?? 0;
-  }
-
-  return {
-    items: rows.map(({ total: _total, ...row }) => row as TTable['$inferSelect']),
-    total,
-    limit: options.pagination.limit,
-    offset: options.pagination.offset,
-  };
-}