@manablox/db 0.1.0 → 0.2.0

package/test/menu.test.ts

@@ -0,0 +1,126 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { isUniqueViolation } from '../src/errors.js';
+import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
+
+let ctx: RepositoryTestContext;
+
+beforeAll(async () => {
+  ctx = await createRepositoryContext('menu');
+});
+afterAll(async () => {
+  await ctx?.close();
+});
+
+const menu = (machineName: string) =>
+  ctx.repos.menus.create({ spaceId: ctx.spaceId, name: machineName, machineName });
+
+describe('menus', () => {
+  it('stores a nested tree and reads it back in order', async () => {
+    const main = await menu('main');
+    const home = await makeNode(ctx, { title: 'Home', slug: 'home' });
+    const about = await makeNode(ctx, { title: 'About', slug: 'about' });
+    const team = await makeNode(ctx, { title: 'Team', slug: 'team', parentId: about.id });
+
+    await ctx.repos.menus.setItems(main.id, [
+      { localizationId: home.localizationId },
+      {
+        localizationId: about.localizationId,
+        label: 'Who we are',
+        children: [
+          { localizationId: team.localizationId },
+          { url: 'https://jobs.example', label: 'Jobs' },
+        ],
+      },
+    ]);
+
+    const tree = await ctx.repos.menus.tree(main.id);
+    expect(tree.map((node) => node.item.localizationId)).toEqual([
+      home.localizationId,
+      about.localizationId,
+    ]);
+    expect(tree[1]?.item.label).toBe('Who we are');
+    expect(tree[1]?.children.map((node) => node.item.url)).toEqual([null, 'https://jobs.example']);
+  });
+
+  it('keeps an entry’s id across saves when it is handed back', async () => {
+    const footer = await menu('footer');
+    const legal = await makeNode(ctx, { title: 'Legal', slug: 'legal' });
+    const [first] = await ctx.repos.menus.setItems(footer.id, [
+      { localizationId: legal.localizationId },
+    ]);
+    const [second] = await ctx.repos.menus.setItems(footer.id, [
+      { id: first?.item.id, localizationId: legal.localizationId, label: 'Imprint' },
+    ]);
+    expect(second?.item.id).toBe(first?.item.id);
+    expect(second?.item.label).toBe('Imprint');
+  });
+
+  it('resolves each entry to the document of the requested locale, published or draft', async () => {
+    const nav = await menu('nav');
+    const en = await makeNode(ctx, { title: 'Contact', slug: 'contact' });
+    const de = await ctx.repos.content.create({
+      spaceId: ctx.spaceId,
+      typeId: ctx.types.page.id,
+      locale: 'de',
+      localizationId: en.localizationId,
+      parentId: null,
+      title: 'Kontakt',
+      slug: 'kontakt',
+      fields: {},
+      hasSlug: true,
+    });
+    const onlyEnglish = await makeNode(ctx, { title: 'Blog', slug: 'blog' });
+    await ctx.repos.menus.setItems(nav.id, [
+      { localizationId: en.localizationId },
+      { localizationId: onlyEnglish.localizationId },
+      { url: '/rss', label: 'Feed' },
+    ]);
+
+    const german = await ctx.repos.menus.resolve(nav, 'de');
+    expect(german.map((item) => item.content?.title ?? null)).toEqual(['Kontakt', null, null]);
+    expect(german[1]?.localizationId).toBe(onlyEnglish.localizationId);
+
+    // Nothing is published yet, so the delivery view has no documents at all.
+    const live = await ctx.repos.menus.resolve(nav, 'de', true);
+    expect(live.map((item) => item.content)).toEqual([null, null, null]);
+
+    await ctx.repos.content.publish(de.id);
+    const afterPublish = await ctx.repos.menus.resolve(nav, 'de', true);
+    expect(afterPublish[0]?.content?.title).toBe('Kontakt');
+    expect(afterPublish[0]?.content?.status).toBe('published');
+  });
+
+  it('removes a document from every menu, sub-entries included', async () => {
+    const a = await menu('a');
+    const b = await menu('b');
+    const parent = await makeNode(ctx, { title: 'Parent', slug: 'parent' });
+    const child = await makeNode(ctx, { title: 'Child', slug: 'child', parentId: parent.id });
+    await ctx.repos.menus.setItems(a.id, [
+      {
+        localizationId: parent.localizationId,
+        children: [{ localizationId: child.localizationId }],
+      },
+    ]);
+    await ctx.repos.menus.setItems(b.id, [{ localizationId: parent.localizationId }]);
+
+    const referencing = await ctx.repos.menus.menusReferencing(ctx.spaceId, parent.localizationId);
+    expect(referencing.map((row) => row.machineName).sort()).toEqual(['a', 'b']);
+
+    expect(await ctx.repos.menus.removeContent(parent.localizationId)).toBe(2);
+    expect(await ctx.repos.menus.items(a.id)).toEqual([]);
+    expect(await ctx.repos.menus.items(b.id)).toEqual([]);
+  });
+
+  it('deletes a menu with its entries and refuses a duplicate technical name', async () => {
+    const gone = await menu('gone');
+    const page = await makeNode(ctx, { title: 'Gone', slug: 'gone' });
+    await ctx.repos.menus.setItems(gone.id, [{ localizationId: page.localizationId }]);
+    await ctx.repos.menus.delete(gone.id);
+    expect(await ctx.repos.menus.findById(gone.id)).toBeNull();
+    expect(await ctx.repos.menus.items(gone.id)).toEqual([]);
+
+    await expect(menu('main')).rejects.toSatisfy((error: unknown) =>
+      isUniqueViolation(error, 'menus_space_machine_name_key'),
+    );
+  });
+});

package/test/publish.test.ts

@@ -1,10 +1,10 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createTestContext, makeNode, type TestContext } from './helpers.js';
+import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
 
-let ctx: TestContext;
+let ctx: RepositoryTestContext;
 
 beforeAll(async () => {
-  ctx = await createTestContext('publish');
+  ctx = await createRepositoryContext('publish');
 });
 afterAll(async () => {
   await ctx?.close();
@@ -100,3 +100,31 @@ describe('versions and optimistic locking', () => {
     );
   });
 });
+
+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,11 +1,11 @@
 import { sql } from 'drizzle-orm';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createTestContext, makeNode, type TestContext } from './helpers.js';
+import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
 
-let ctx: TestContext;
+let ctx: RepositoryTestContext;
 
 beforeAll(async () => {
-  ctx = await createTestContext('query');
+  ctx = await createRepositoryContext('query');
   await makeNode(ctx, {
     title: 'Alpha',
     slug: 'alpha',
@@ -138,3 +138,33 @@ describe('full-text search', () => {
     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

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

package/test/user.test.ts

@@ -0,0 +1,126 @@
+import { eq } from 'drizzle-orm';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { accounts, memberships, sessions } from '../src/schema/index.js';
+import { createRepositoryContext, type RepositoryTestContext } from '../src/testing.js';
+
+let ctx: RepositoryTestContext;
+
+beforeAll(async () => {
+  ctx = await createRepositoryContext('user');
+});
+afterAll(async () => {
+  await ctx?.close();
+});
+
+const stamp = () => Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+
+describe('UserRepository.create', () => {
+  it('writes the credential the way better-auth 1.7 looks it up', async () => {
+    const user = await ctx.repos.users.create({
+      name: 'Sam',
+      email: `sam-${stamp()}@example.com`,
+      role: 'editor',
+      passwordHash: '$argon2id$hash',
+    });
+
+    const rows = await ctx.handle.db.select().from(accounts).where(eq(accounts.userId, user.id));
+    expect(rows).toHaveLength(1);
+    // Sign-in matches on all three; a row missing the issuer is invisible to it.
+    expect(rows[0]).toMatchObject({
+      providerId: 'credential',
+      issuer: 'local:credential',
+      accountId: user.id,
+      password: '$argon2id$hash',
+    });
+  });
+
+  it('refuses a second account on the same email', async () => {
+    const email = `dup-${stamp()}@example.com`;
+    const make = () =>
+      ctx.repos.users.create({ name: 'A', email, role: 'editor', passwordHash: 'x' });
+    await make();
+    await expect(make()).rejects.toMatchObject({ cause: { code: '23505' } });
+  });
+});
+
+describe('UserRepository passwords and sessions', () => {
+  it('replaces the credential rather than adding a second one', async () => {
+    const user = await ctx.repos.users.create({
+      name: 'Pat',
+      email: `pat-${stamp()}@example.com`,
+      role: 'editor',
+      passwordHash: 'old',
+    });
+    await ctx.repos.users.setPasswordHash(user.id, 'new');
+
+    const rows = await ctx.handle.db.select().from(accounts).where(eq(accounts.userId, user.id));
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.password).toBe('new');
+  });
+
+  it('revokes every session of one user and nobody else', async () => {
+    const [a, b] = await Promise.all(
+      ['a', 'b'].map((n) =>
+        ctx.repos.users.create({
+          name: n,
+          email: `${n}-${stamp()}@example.com`,
+          role: 'editor',
+          passwordHash: 'x',
+        }),
+      ),
+    );
+    const expiresAt = new Date(Date.now() + 60_000);
+    await ctx.handle.db.insert(sessions).values([
+      { userId: a!.id, token: `a1-${stamp()}`, expiresAt },
+      { userId: a!.id, token: `a2-${stamp()}`, expiresAt },
+      { userId: b!.id, token: `b1-${stamp()}`, expiresAt },
+    ]);
+
+    await ctx.repos.users.revokeSessions(a!.id);
+
+    expect(
+      await ctx.handle.db.select().from(sessions).where(eq(sessions.userId, a!.id)),
+    ).toHaveLength(0);
+    expect(
+      await ctx.handle.db.select().from(sessions).where(eq(sessions.userId, b!.id)),
+    ).toHaveLength(1);
+  });
+});
+
+describe('UserRepository.delete', () => {
+  it('takes the credential and the memberships with it', async () => {
+    const user = await ctx.repos.users.create({
+      name: 'Gone',
+      email: `gone-${stamp()}@example.com`,
+      role: 'editor',
+      passwordHash: 'x',
+    });
+    await ctx.repos.users.grant(user.id, ctx.spaceId, 'viewer');
+    expect(await ctx.repos.users.membershipsWithSpaces(user.id)).toMatchObject([
+      { role: 'viewer', space: { id: ctx.spaceId } },
+    ]);
+
+    await ctx.repos.users.delete(user.id);
+
+    expect(await ctx.repos.users.findById(user.id)).toBeNull();
+    expect(
+      await ctx.handle.db.select().from(accounts).where(eq(accounts.userId, user.id)),
+    ).toHaveLength(0);
+    expect(
+      await ctx.handle.db.select().from(memberships).where(eq(memberships.userId, user.id)),
+    ).toHaveLength(0);
+  });
+});
+
+describe('UserRepository.countByRole', () => {
+  it('counts the instance role', async () => {
+    const before = await ctx.repos.users.countByRole('superadmin');
+    await ctx.repos.users.create({
+      name: 'Root',
+      email: `root-${stamp()}@example.com`,
+      role: 'superadmin',
+      passwordHash: 'x',
+    });
+    expect(await ctx.repos.users.countByRole('superadmin')).toBe(before + 1);
+  });
+});

package/test/webhook.test.ts

@@ -0,0 +1,48 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { webhooks } from '../src/schema/index.js';
+import { createRepositoryContext, type RepositoryTestContext } from '../src/testing.js';
+
+let ctx: RepositoryTestContext;
+
+beforeAll(async () => {
+  ctx = await createRepositoryContext('webhook');
+});
+afterAll(async () => {
+  await ctx?.close();
+});
+
+describe('webhooks', () => {
+  it('lists only the switched-on webhooks of a space and logs deliveries', async () => {
+    const [on, off] = await ctx.handle.db
+      .insert(webhooks)
+      .values([
+        { spaceId: ctx.spaceId, name: 'On', url: 'https://on.test', events: [] },
+        { spaceId: ctx.spaceId, name: 'Off', url: 'https://off.test', events: [], enabled: false },
+      ])
+      .returning();
+
+    const enabled = await ctx.repos.webhooks.findEnabled(ctx.spaceId);
+    expect(enabled.map((row) => row.id)).toEqual([on?.id]);
+    expect(await ctx.repos.webhooks.findById(off?.id as string)).toMatchObject({ enabled: false });
+
+    await ctx.repos.webhooks.recordDelivery({
+      webhookId: on?.id as string,
+      event: 'content.published',
+      payload: { id: 'x' },
+      status: 200,
+      error: null,
+    });
+    await ctx.repos.webhooks.recordDelivery({
+      webhookId: on?.id as string,
+      event: 'content.published',
+      payload: { id: 'y' },
+      status: null,
+      error: 'ECONNREFUSED',
+    });
+    const log = await ctx.repos.webhooks.deliveries(on?.id as string);
+    expect(log.map((row) => [row.status, row.error])).toEqual([
+      [200, null],
+      [null, 'ECONNREFUSED'],
+    ]);
+  });
+});

package/vitest.config.ts

@@ -6,7 +6,5 @@ export default defineConfig({
     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,
   },
 });