@manablox/db 0.2.0 → 0.4.0

package/test/publish.test.ts

@@ -1,130 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
-
-let ctx: RepositoryTestContext;
-
-beforeAll(async () => {
-  ctx = await createRepositoryContext('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/,
-    );
-  });
-});
-
-describe('republishing', () => {
-  it('rewrites descendants published beneath a parent that was not yet projected', async () => {
-    const root = await makeNode(ctx, { title: 'Late', slug: 'late' });
-    const child = await makeNode(ctx, { title: 'Early', slug: 'early', parentId: root.id });
-    // The child goes live first. Its parent is not in the projection, so it is
-    // transparent in the published path until it is published too.
-    await ctx.repos.content.publish(child.id);
-    expect((await ctx.repos.content.findById(child.id, true))?.permalink).toBe('early');
-
-    await update(root.id, { title: 'Late', slug: 'later', parentId: null });
-    await ctx.repos.content.publish(root.id);
-
-    expect((await ctx.repos.content.findById(child.id, true))?.permalink).toBe('later/early');
-  });
-
-  it('skips the subtree walk when a republish leaves the permalink path alone', async () => {
-    const node = await makeNode(ctx, { title: 'Same', slug: 'same', fields: { body: 'v1' } });
-    await ctx.repos.content.publish(node.id);
-    await update(node.id, { title: 'Same', slug: 'same', fields: { body: 'v2' } });
-
-    ctx.queries.length = 0;
-    await ctx.repos.content.publish(node.id);
-
-    expect(ctx.queries.some((query) => /with recursive/i.test(query))).toBe(false);
-    expect((await ctx.repos.content.findById(node.id, true))?.fields).toEqual({ body: 'v2' });
-  });
-});

package/test/query.test.ts

@@ -1,170 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
-
-let ctx: RepositoryTestContext;
-
-beforeAll(async () => {
-  ctx = await createRepositoryContext('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']);
-  });
-});
-
-describe('paginate', () => {
-  it('answers a page and the total in one statement, and the true total past the end', async () => {
-    const { paginate } = await import('../src/pagination.js');
-    const { users } = await import('../src/schema/index.js');
-    for (const n of [1, 2, 3]) {
-      await ctx.repos.users.create({
-        name: `P${n}`,
-        email: `p${n}@example.com`,
-        role: 'editor',
-        passwordHash: 'x',
-      });
-    }
-    ctx.queries.length = 0;
-    const first = await paginate(ctx.handle.db, users, {
-      orderBy: users.createdAt,
-      pagination: { limit: 2, offset: 0 },
-    });
-    expect(first.items).toHaveLength(2);
-    expect(first.total).toBe(3);
-    expect(ctx.queries).toHaveLength(1);
-
-    const past = await paginate(ctx.handle.db, users, {
-      orderBy: users.createdAt,
-      pagination: { limit: 2, offset: 10 },
-    });
-    expect(past.items).toEqual([]);
-    expect(past.total).toBe(3);
-  });
-});

package/test/role.test.ts

@@ -1,81 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createRepositoryContext, type RepositoryTestContext } from '../src/testing.js';
-
-let ctx: RepositoryTestContext;
-
-beforeAll(async () => {
-  ctx = await createRepositoryContext('role');
-});
-afterAll(async () => {
-  await ctx?.close();
-});
-
-const stamp = () => Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-
-describe('RoleRepository and the principal', () => {
-  it('resolves a membership naming a custom role to that role’s grants', async () => {
-    const role = await ctx.repos.roles.create(ctx.spaceId, {
-      name: 'Blogger',
-      machineName: `blogger-${stamp()}`,
-      permissions: ['space:read', `content:write:${ctx.types.page.id}`],
-    });
-    const user = await ctx.repos.users.create({
-      name: 'Blogger',
-      email: `blogger-${stamp()}@example.com`,
-      role: 'editor',
-      passwordHash: 'x',
-    });
-    await ctx.repos.users.grant(user.id, ctx.spaceId, role.machineName);
-
-    const principal = await ctx.repos.users.principal(user.id);
-    expect(principal?.spaces).toEqual({ [ctx.spaceId]: role.machineName });
-    expect(principal?.permissions).toEqual({ [ctx.spaceId]: role.permissions });
-    expect(await ctx.repos.roles.countMembers(ctx.spaceId, role.machineName)).toBe(1);
-  });
-
-  it('carries no grants for a built-in role, which the auth package knows itself', async () => {
-    const user = await ctx.repos.users.create({
-      name: 'Editor',
-      email: `editor-${stamp()}@example.com`,
-      role: 'editor',
-      passwordHash: 'x',
-    });
-    await ctx.repos.users.grant(user.id, ctx.spaceId, 'editor');
-    const principal = await ctx.repos.users.principal(user.id);
-    expect(principal?.spaces).toEqual({ [ctx.spaceId]: 'editor' });
-    expect(principal?.permissions).toEqual({});
-  });
-
-  it('prunes the grants naming a content type from every role, keeping the rest', async () => {
-    const gone = '99999999-9999-4999-8999-999999999999';
-    const a = await ctx.repos.roles.create(ctx.spaceId, {
-      name: 'A',
-      machineName: `a-${stamp()}`,
-      permissions: ['space:read', `content:read:${gone}`, `content:write:${ctx.types.page.id}`],
-    });
-    const b = await ctx.repos.roles.create(ctx.spaceId, {
-      name: 'B',
-      machineName: `b-${stamp()}`,
-      permissions: ['space:read', 'content:read'],
-    });
-
-    await ctx.repos.roles.pruneContentType(gone);
-
-    expect((await ctx.repos.roles.findById(a.id))?.permissions).toEqual([
-      'space:read',
-      `content:write:${ctx.types.page.id}`,
-    ]);
-    expect((await ctx.repos.roles.findById(b.id))?.permissions).toEqual([
-      'space:read',
-      'content:read',
-    ]);
-  });
-
-  it('refuses two roles with one machine name in a space', async () => {
-    const machineName = `dup-${stamp()}`;
-    const make = () =>
-      ctx.repos.roles.create(ctx.spaceId, { name: 'Dup', machineName, permissions: [] });
-    await make();
-    await expect(make()).rejects.toMatchObject({ cause: { code: '23505' } });
-  });
-});

package/test/tree.test.ts

@@ -1,188 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
-
-let ctx: RepositoryTestContext;
-
-beforeAll(async () => {
-  ctx = await createRepositoryContext('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();
-  });
-});