@manablox/db 0.1.0 → 0.3.0

package/test/helpers.ts

@@ -1,153 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-  type ContentTypeDefinition,
-  ContentTypeRegistry,
-  defineContentType,
-  defineFieldType,
-  FieldTypeRegistry,
-  type StandardSchemaV1,
-} from '@manablox/core';
-import { migrate } from 'drizzle-orm/postgres-js/migrator';
-import postgres from 'postgres';
-import { applyBootstrapSql } from '../src/bootstrap.js';
-import { createDatabase, type DatabaseHandle } from '../src/client.js';
-import { createRepositories, type Repositories } from '../src/repositories/index.js';
-
-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 ADMIN_URL =
-  process.env.TEST_DATABASE_URL ??
-  process.env.DATABASE_URL ??
-  'postgres://manablox:manablox@localhost:5432/manablox';
-
-const anySchema = <T>(): StandardSchemaV1<unknown, T> => ({
-  '~standard': { version: 1, vendor: 'test', validate: (value) => ({ value: value as T }) },
-});
-
-export const stringField = defineFieldType({
-  name: 'string',
-  label: 'Text',
-  settingsSchema: anySchema<Record<string, unknown>>(),
-  valueSchema: () => anySchema<string>(),
-  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' },
-});
-
-export const numberField = defineFieldType({
-  name: 'number',
-  label: 'Number',
-  settingsSchema: anySchema<Record<string, unknown>>(),
-  valueSchema: () => anySchema<number>(),
-  defaultValue: () => 0,
-  storage: { kind: 'jsonb', index: 'btree' },
-  filters: ['eq', 'lt', 'lte', 'gt', 'gte'],
-  graphql: { type: { kind: 'scalar', name: 'Float' } },
-  admin: { input: 'number' },
-});
-
-export interface TestContext {
-  handle: DatabaseHandle;
-  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 async function createTestContext(name: string): Promise<TestContext> {
-  const dbName = `manablox_test_${name}_${Date.now().toString(36)}`;
-  const admin = postgres(ADMIN_URL, { max: 1 });
-  await admin.unsafe(`create database "${dbName}"`);
-  await admin.end();
-
-  const url = ADMIN_URL.replace(/\/[^/]*$/, `/${dbName}`);
-  const handle = createDatabase({ url, max: 4 });
-  await applyBootstrapSql(handle.sql);
-  await migrate(handle.db, { migrationsFolder: MIGRATIONS });
-
-  const fieldTypes = new FieldTypeRegistry();
-  fieldTypes.register(stringField);
-  fieldTypes.register(numberField);
-
-  const page = defineContentType({
-    name: 'page',
-    fields: [
-      { name: 'body', type: 'string' },
-      { name: 'weight', type: 'number' },
-    ],
-  });
-  // A type without a slug: it must be transparent in descendants' permalinks.
-  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,
-    repos,
-    registry,
-    types: { page, folder },
-    spaceId: space.id,
-    close: async () => {
-      await handle.close();
-      const cleanup = postgres(ADMIN_URL, { max: 1 });
-      await cleanup.unsafe(`drop database if exists "${dbName}" with (force)`);
-      await cleanup.end();
-    },
-  };
-}
-
-/** Convenience creator so tests read as tree shapes rather than field soup. */
-export async function makeNode(
-  ctx: TestContext,
-  options: {
-    title: string;
-    slug: string;
-    parentId?: string | null;
-    type?: 'page' | 'folder';
-    fields?: Record<string, unknown>;
-  },
-) {
-  const type = ctx.types[options.type ?? 'page'];
-  // The content service derives `searchText` from each field type's `search()`
-  // contribution; the repository stores what it is given. Mirror that here.
-  const searchText = Object.values(options.fields ?? {})
-    .filter((value): value is string => 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,
-  });
-}

package/test/publish.test.ts

@@ -1,102 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createTestContext, makeNode, type TestContext } from './helpers.js';
-
-let ctx: TestContext;
-
-beforeAll(async () => {
-  ctx = await createTestContext('publish');
-});
-afterAll(async () => {
-  await ctx?.close();
-});
-
-const update = (id: string, over: Record<string, unknown>) =>
-  ctx.repos.content.update(id, {
-    spaceId: ctx.spaceId,
-    typeId: ctx.types.page.id,
-    locale: 'en',
-    title: 'T',
-    slug: 's',
-    fields: {},
-    hasSlug: true,
-    ...over,
-  } as never);
-
-describe('publishing', () => {
-  it('projects a draft into the delivery table', async () => {
-    const node = await makeNode(ctx, { title: 'Post', slug: 'post', fields: { body: 'v1' } });
-    expect(await ctx.repos.content.findById(node.id, true)).toBeNull();
-
-    await ctx.repos.content.publish(node.id);
-
-    const published = await ctx.repos.content.findById(node.id, true);
-    expect(published?.permalink).toBe('post');
-    expect(published?.status).toBe('published');
-    expect((published?.fields as Record<string, unknown>).body).toBe('v1');
-  });
-
-  it('keeps the draft and the published projection independent', async () => {
-    const node = await makeNode(ctx, {
-      title: 'Draftable',
-      slug: 'draftable',
-      fields: { body: 'v1' },
-    });
-    await ctx.repos.content.publish(node.id);
-
-    await update(node.id, { title: 'Draftable', slug: 'draftable', fields: { body: 'v2' } });
-
-    const draft = await ctx.repos.content.findById(node.id);
-    const published = await ctx.repos.content.findById(node.id, true);
-    expect((draft?.fields as Record<string, unknown>).body).toBe('v2');
-    expect((published?.fields as Record<string, unknown>).body).toBe('v1');
-  });
-
-  it('rewrites published descendants when the parent permalink changes', async () => {
-    const root = await makeNode(ctx, { title: 'R', slug: 'r' });
-    const child = await makeNode(ctx, { title: 'C', slug: 'c', parentId: root.id });
-    await ctx.repos.content.publish(root.id);
-    await ctx.repos.content.publish(child.id);
-
-    await update(root.id, { title: 'R', slug: 'renamed', parentId: null });
-    await ctx.repos.content.publish(root.id);
-
-    const publishedChild = await ctx.repos.content.findById(child.id, true);
-    expect(publishedChild?.permalink).toBe('renamed/c');
-  });
-
-  it('removes the subtree from the projection on unpublish', async () => {
-    const root = await makeNode(ctx, { title: 'U', slug: 'u' });
-    const child = await makeNode(ctx, { title: 'U1', slug: 'u1', parentId: root.id });
-    await ctx.repos.content.publish(root.id);
-    await ctx.repos.content.publish(child.id);
-
-    await ctx.repos.content.unpublish(root.id);
-
-    expect(await ctx.repos.content.findById(root.id, true)).toBeNull();
-    expect(await ctx.repos.content.findById(child.id, true)).toBeNull();
-  });
-});
-
-describe('versions and optimistic locking', () => {
-  it('snapshots every save', async () => {
-    const node = await makeNode(ctx, { title: 'V', slug: 'v', fields: { body: 'one' } });
-    await update(node.id, { title: 'V', slug: 'v', fields: { body: 'two' } });
-    await update(node.id, { title: 'V', slug: 'v', fields: { body: 'three' } });
-
-    const versions = await ctx.repos.content.versions(node.id);
-    expect(versions.map((v) => v.version)).toEqual([3, 2, 1]);
-
-    const first = await ctx.repos.content.versionSnapshot(node.id, 1);
-    expect((first?.fields as Record<string, unknown>).body).toBe('one');
-  });
-
-  /** Optimistic locking: a stale version must not silently win. */
-  it('rejects a write built on a stale version', async () => {
-    const node = await makeNode(ctx, { title: 'L', slug: 'lock' });
-    await update(node.id, { title: 'L', slug: 'lock', expectedVersion: 1 });
-
-    await expect(update(node.id, { title: 'L', slug: 'lock', expectedVersion: 1 })).rejects.toThrow(
-      /version.conflict/,
-    );
-  });
-});

package/test/query.test.ts

@@ -1,140 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createTestContext, makeNode, type TestContext } from './helpers.js';
-
-let ctx: TestContext;
-
-beforeAll(async () => {
-  ctx = await createTestContext('query');
-  await makeNode(ctx, {
-    title: 'Alpha',
-    slug: 'alpha',
-    fields: { body: 'hello world', weight: 5 },
-  });
-  await makeNode(ctx, {
-    title: 'Beta',
-    slug: 'beta',
-    fields: { body: 'goodbye world', weight: 10 },
-  });
-  await makeNode(ctx, {
-    title: 'Gamma',
-    slug: 'gamma',
-    fields: { body: 'hello again', weight: 15 },
-  });
-});
-afterAll(async () => {
-  await ctx?.close();
-});
-
-const page = (extra: Record<string, unknown> = {}) => ({
-  spaceId: ctx.spaceId,
-  typeIds: [ctx.types.page.id],
-  ...extra,
-});
-
-describe('field filters', () => {
-  it('filters by equality through jsonb containment', async () => {
-    const result = await ctx.repos.content.list(
-      page({ fields: [{ name: 'body', op: 'eq' as const, value: 'hello world' }] }),
-      { limit: 10, offset: 0 },
-    );
-    expect(result.items.map((i) => i.slug)).toEqual(['alpha']);
-    expect(result.total).toBe(1);
-  });
-
-  it('filters by substring', async () => {
-    const result = await ctx.repos.content.list(
-      page({ fields: [{ name: 'body', op: 'contains' as const, value: 'hello' }] }),
-      { limit: 10, offset: 0 },
-    );
-    expect(result.items.map((i) => i.slug).sort()).toEqual(['alpha', 'gamma']);
-  });
-
-  it('filters numerically', async () => {
-    const result = await ctx.repos.content.list(
-      page({ fields: [{ name: 'weight', op: 'gt' as const, value: 7 }] }),
-      { limit: 10, offset: 0 },
-    );
-    expect(result.items.map((i) => i.slug).sort()).toEqual(['beta', 'gamma']);
-  });
-
-  /** Only operators the field type declares are accepted; the rest are rejected. */
-  it('rejects an operator the field type does not declare', async () => {
-    await expect(
-      ctx.repos.content.list(
-        page({ fields: [{ name: 'weight', op: 'contains' as const, value: 'x' }] }),
-        { limit: 10, offset: 0 },
-      ),
-    ).rejects.toThrow(/operator.unsupported/);
-  });
-
-  it('rejects a field that does not exist on the content type', async () => {
-    await expect(
-      ctx.repos.content.list(page({ fields: [{ name: 'nope', op: 'eq' as const, value: 1 }] }), {
-        limit: 10,
-        offset: 0,
-      }),
-    ).rejects.toThrow(/field.unknown/);
-  });
-
-  it('escapes LIKE metacharacters instead of letting them act as wildcards', async () => {
-    await makeNode(ctx, { title: 'Pct', slug: 'pct', fields: { body: '100% sure', weight: 1 } });
-    const result = await ctx.repos.content.list(
-      page({ fields: [{ name: 'body', op: 'contains' as const, value: '100%' }] }),
-      { limit: 10, offset: 0 },
-    );
-    expect(result.items.map((i) => i.slug)).toEqual(['pct']);
-  });
-
-  it('returns the page and its total in one round trip', async () => {
-    const result = await ctx.repos.content.list(page(), { limit: 2, offset: 0 });
-    expect(result.items).toHaveLength(2);
-    expect(result.total).toBeGreaterThanOrEqual(4);
-  });
-});
-
-describe('index coverage', () => {
-  /** Every lookup key — `contentId`, `parent`, `permalink`, `space`, `locale` — is indexed. */
-  it('uses the GiST path index for subtree queries', async () => {
-    const root = await makeNode(ctx, { title: 'IdxRoot', slug: 'idx-root' });
-    for (let i = 0; i < 200; i++) {
-      await makeNode(ctx, { title: `n${i}`, slug: `idx-${i}`, parentId: root.id });
-    }
-    await ctx.handle.sql.unsafe('analyze contents');
-
-    const plan = await ctx.handle.db.execute<{ 'QUERY PLAN': string }>(sql`
-      explain (format text)
-      select * from contents
-      where path <@ (select path from contents where id = ${root.id}::uuid)
-    `);
-    const text = (plan as unknown as Array<Record<string, string>>)
-      .map((row) => Object.values(row)[0])
-      .join('\n');
-
-    expect(text).toMatch(/contents_path_gist_idx/);
-  });
-
-  it('uses the permalink unique index for delivery lookups', async () => {
-    await ctx.handle.sql.unsafe('analyze contents');
-    const plan = await ctx.handle.db.execute<Record<string, string>>(sql`
-      explain (format text)
-      select * from contents
-      where space_id = ${ctx.spaceId}::uuid and locale = 'en' and permalink = 'alpha'
-    `);
-    const text = (plan as unknown as Array<Record<string, string>>)
-      .map((row) => Object.values(row)[0])
-      .join('\n');
-
-    expect(text).toMatch(/contents_permalink_key/);
-  });
-});
-
-describe('full-text search', () => {
-  it('matches on the generated tsvector', async () => {
-    const result = await ctx.repos.content.list(page({ search: 'goodbye' }), {
-      limit: 10,
-      offset: 0,
-    });
-    expect(result.items.map((i) => i.slug)).toEqual(['beta']);
-  });
-});

package/test/tree.test.ts

@@ -1,188 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createTestContext, makeNode, type TestContext } from './helpers.js';
-
-let ctx: TestContext;
-
-beforeAll(async () => {
-  ctx = await createTestContext('tree');
-});
-afterAll(async () => {
-  await ctx?.close();
-});
-
-describe('permalinks', () => {
-  it('derives a permalink from the ancestor chain', async () => {
-    const root = await makeNode(ctx, { title: 'Root', slug: 'root' });
-    const child = await makeNode(ctx, { title: 'Child', slug: 'child', parentId: root.id });
-    const grandchild = await makeNode(ctx, { title: 'GC', slug: 'gc', parentId: child.id });
-
-    expect(root.permalink).toBe('root');
-    expect(child.permalink).toBe('root/child');
-    expect(grandchild.permalink).toBe('root/child/gc');
-  });
-
-  it('is transparent for a content type that has no slug', async () => {
-    const root = await makeNode(ctx, { title: 'Docs', slug: 'docs' });
-    const folder = await makeNode(ctx, {
-      title: 'Hidden',
-      slug: 'hidden',
-      parentId: root.id,
-      type: 'folder',
-    });
-    const leaf = await makeNode(ctx, { title: 'Leaf', slug: 'leaf', parentId: folder.id });
-
-    // A slug-less type is a structural container, not a page: it holds no permalink of
-    // its own (which would otherwise collide with its parent's) and is skipped in its
-    // descendants' paths.
-    expect(folder.permalink).toBeNull();
-    expect(folder.permalinkPath).toBe('docs');
-    expect(leaf.permalink).toBe('docs/leaf');
-  });
-
-  it('keeps descendants correct when a slug-less level sits mid-chain and a slug changes', async () => {
-    const root = await makeNode(ctx, { title: 'Site', slug: 'site' });
-    const folder = await makeNode(ctx, {
-      title: 'Group',
-      slug: 'group',
-      parentId: root.id,
-      type: 'folder',
-    });
-    const leaf = await makeNode(ctx, { title: 'Deep', slug: 'deep', parentId: folder.id });
-
-    expect(leaf.permalink).toBe('site/deep');
-
-    await ctx.repos.content.update(root.id, {
-      spaceId: ctx.spaceId,
-      typeId: ctx.types.page.id,
-      locale: 'en',
-      parentId: null,
-      title: 'Site',
-      slug: 'website',
-      fields: {},
-      hasSlug: true,
-    });
-
-    const [nf, nl] = await Promise.all([
-      ctx.repos.content.findById(folder.id),
-      ctx.repos.content.findById(leaf.id),
-    ]);
-    expect(nf?.permalink).toBeNull();
-    expect(nf?.permalinkPath).toBe('website');
-    expect(nl?.permalink).toBe('website/deep');
-  });
-
-  /** A deep node's permalink derives from its own parent, not its grandparent. */
-  it('rewrites the whole subtree when a slug changes — grandchildren included', async () => {
-    const a = await makeNode(ctx, { title: 'A', slug: 'a' });
-    const b = await makeNode(ctx, { title: 'B', slug: 'b', parentId: a.id });
-    const c = await makeNode(ctx, { title: 'C', slug: 'c', parentId: b.id });
-    const d = await makeNode(ctx, { title: 'D', slug: 'd', parentId: c.id });
-
-    expect(d.permalink).toBe('a/b/c/d');
-
-    await ctx.repos.content.update(a.id, {
-      spaceId: ctx.spaceId,
-      typeId: ctx.types.page.id,
-      locale: 'en',
-      parentId: null,
-      title: 'A',
-      slug: 'alpha',
-      fields: {},
-      hasSlug: true,
-    });
-
-    const [nb, nc, nd] = await Promise.all([
-      ctx.repos.content.findById(b.id),
-      ctx.repos.content.findById(c.id),
-      ctx.repos.content.findById(d.id),
-    ]);
-
-    expect(nb?.permalink).toBe('alpha/b');
-    expect(nc?.permalink).toBe('alpha/b/c');
-    // The bug produced 'alpha/b/d' here — the grandparent's prefix plus the leaf slug.
-    expect(nd?.permalink).toBe('alpha/b/c/d');
-  });
-
-  it('rebases paths and permalinks when a subtree is reparented', async () => {
-    const home = await makeNode(ctx, { title: 'Home', slug: 'home' });
-    const shop = await makeNode(ctx, { title: 'Shop', slug: 'shop' });
-    const cat = await makeNode(ctx, { title: 'Cat', slug: 'cat', parentId: home.id });
-    const item = await makeNode(ctx, { title: 'Item', slug: 'item', parentId: cat.id });
-
-    expect(item.permalink).toBe('home/cat/item');
-
-    await ctx.repos.content.update(cat.id, {
-      spaceId: ctx.spaceId,
-      typeId: ctx.types.page.id,
-      locale: 'en',
-      parentId: shop.id,
-      title: 'Cat',
-      slug: 'cat',
-      fields: {},
-      hasSlug: true,
-    });
-
-    const movedItem = await ctx.repos.content.findById(item.id);
-    expect(movedItem?.permalink).toBe('shop/cat/item');
-    // The ltree path must be rebased too, or subtree queries silently miss the node.
-    const movedCat = await ctx.repos.content.findById(cat.id);
-    expect(movedItem?.path.startsWith(`${movedCat?.path}.`)).toBe(true);
-  });
-
-  it('refuses to make a node its own descendant', async () => {
-    const a = await makeNode(ctx, { title: 'X', slug: 'x' });
-    const b = await makeNode(ctx, { title: 'Y', slug: 'y', parentId: a.id });
-
-    await expect(
-      ctx.repos.content.update(a.id, {
-        spaceId: ctx.spaceId,
-        typeId: ctx.types.page.id,
-        locale: 'en',
-        parentId: b.id,
-        title: 'X',
-        slug: 'x',
-        fields: {},
-        hasSlug: true,
-      }),
-    ).rejects.toThrow(/cycle/);
-  });
-
-  it('rejects duplicate slugs among root-level siblings (NULLS NOT DISTINCT)', async () => {
-    await makeNode(ctx, { title: 'Dup', slug: 'duplicate-root' });
-    await expect(makeNode(ctx, { title: 'Dup2', slug: 'duplicate-root' })).rejects.toThrow();
-  });
-});
-
-describe('tree loading', () => {
-  it('returns a whole tree in a single query', async () => {
-    const root = await makeNode(ctx, { title: 'T', slug: 'tree-root' });
-    const l1 = await makeNode(ctx, { title: 'L1', slug: 'l1', parentId: root.id });
-    await makeNode(ctx, { title: 'L2', slug: 'l2', parentId: l1.id });
-    await makeNode(ctx, { title: 'L1b', slug: 'l1b', parentId: root.id });
-
-    const nodes = await ctx.repos.content.tree(ctx.spaceId, 'en', root.id);
-
-    expect(nodes).toHaveLength(2);
-    const first = nodes.find((n) => n.content.slug === 'l1');
-    expect(first?.children.map((c) => c.content.slug)).toEqual(['l2']);
-  });
-
-  it('reads ancestors straight off the materialised path', async () => {
-    const a = await makeNode(ctx, { title: 'A', slug: 'anc-a' });
-    const b = await makeNode(ctx, { title: 'B', slug: 'anc-b', parentId: a.id });
-    const c = await makeNode(ctx, { title: 'C', slug: 'anc-c', parentId: b.id });
-
-    const ancestors = await ctx.repos.content.ancestors(c.id);
-    expect(ancestors.map((row) => row.slug)).toEqual(['anc-a', 'anc-b']);
-  });
-
-  it('deletes a node together with its subtree', async () => {
-    const root = await makeNode(ctx, { title: 'D', slug: 'del-root' });
-    const child = await makeNode(ctx, { title: 'D1', slug: 'del-1', parentId: root.id });
-    await makeNode(ctx, { title: 'D2', slug: 'del-2', parentId: child.id });
-
-    const deleted = await ctx.repos.content.delete(root.id);
-    expect(deleted).toBe(3);
-    expect(await ctx.repos.content.findById(child.id)).toBeNull();
-  });
-});

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "@manablox/config-typescript/library.json",
-  "include": ["src", "test", "drizzle.config.ts"]
-}

package/vitest.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['test/**/*.test.ts'],
-    testTimeout: 60_000,
-    hookTimeout: 60_000,
-    // Each suite owns a database; running them in one process keeps creation cheap.
-    fileParallelism: false,
-  },
-});