@manablox/api-rpc 0.2.0 → 0.4.0

package/test/space.test.ts

@@ -1,170 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { spaceRouter } from '../src/routers/space.js';
-import {
-  failure,
-  invoke,
-  mocks,
-  OTHER_SPACE_ID,
-  OTHER_USER_ID,
-  principal,
-  SPACE_ID,
-  stubContext,
-  superadmin,
-  USER_ID,
-} from './helpers.js';
-
-const space = (overrides = {}) => ({
-  id: SPACE_ID,
-  name: 'Site',
-  machineName: 'site',
-  url: 'http://localhost:3002',
-  defaultLocale: 'en',
-  locales: ['en', 'de'],
-  settings: {},
-  ...overrides,
-});
-
-describe('spaces.list', () => {
-  it('shows a member only their spaces and a superadmin every space', async () => {
-    const ctx = stubContext();
-    const repos = mocks(ctx);
-    repos.spaces.all.mockResolvedValue([space(), space({ id: OTHER_SPACE_ID })]);
-    repos.spaces.findManyByIds.mockImplementation(async (ids: string[]) =>
-      [space(), space({ id: OTHER_SPACE_ID })].filter((s) => ids.includes(s.id)),
-    );
-
-    const own = await invoke<unknown[]>(spaceRouter.list, undefined, ctx);
-    expect(own).toHaveLength(1);
-    // Bounded by membership: the member's call never lists the whole instance.
-    expect(repos.spaces.findManyByIds).toHaveBeenCalledWith([SPACE_ID]);
-    expect(repos.spaces.all).not.toHaveBeenCalled();
-
-    const all = await invoke<unknown[]>(spaceRouter.list, undefined, {
-      ...ctx,
-      principal: superadmin(),
-    });
-    expect(all).toHaveLength(2);
-  });
-
-  it('confines a space-restricted key even for a superadmin', async () => {
-    const ctx = stubContext({
-      principal: superadmin(),
-    });
-    ctx.principal!.allowedSpaceIds = [OTHER_SPACE_ID];
-    mocks(ctx).spaces.all.mockResolvedValue([space(), space({ id: OTHER_SPACE_ID })]);
-    const visible = await invoke<Array<{ id: string }>>(spaceRouter.list, undefined, ctx);
-    expect(visible.map((s) => s.id)).toEqual([OTHER_SPACE_ID]);
-  });
-});
-
-describe('spaces.create', () => {
-  it('requires a superadmin', async () => {
-    const ctx = stubContext();
-    const result = await failure(invoke(spaceRouter.create, space(), ctx));
-    expect(result.code).toBe('FORBIDDEN');
-    expect(result.key).toBe('auth.superadminRequired');
-  });
-
-  it('rejects a default locale outside the locale list', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const result = await failure(
-      invoke(spaceRouter.create, { ...space(), defaultLocale: 'fr' }, ctx),
-    );
-    expect(result.code).toBe('BAD_REQUEST');
-    expect(result.key).toBe('space.validation.failed');
-  });
-
-  it('makes the creator an owner', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.spaces.create!.mockResolvedValue(space());
-
-    await invoke(spaceRouter.create, space(), ctx);
-    expect(repos.users.grant).toHaveBeenCalledWith(USER_ID, SPACE_ID, 'owner');
-  });
-
-  it('turns a taken machine name into a validation error', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.spaces.create!.mockRejectedValue(
-      Object.assign(new Error('Failed query'), {
-        cause: { code: '23505', message: 'duplicate key value violates "spaces_machine_name_key"' },
-      }),
-    );
-
-    const result = await failure(invoke(spaceRouter.create, space(), ctx));
-    expect(result.code).toBe('BAD_REQUEST');
-    expect(result.key).toBe('space.validation.failed');
-  });
-});
-
-describe('spaces.grant / revoke', () => {
-  it('refuses to demote or remove the last owner', async () => {
-    const ctx = stubContext();
-    const repos = mocks(ctx);
-    repos.users.roleIn!.mockResolvedValue('owner');
-    repos.users.membersOf!.mockResolvedValue([{ userId: USER_ID, role: 'owner' }]);
-
-    const demote = await failure(
-      invoke(spaceRouter.grant, { spaceId: SPACE_ID, userId: USER_ID, role: 'editor' }, ctx),
-    );
-    expect(demote.key).toBe('space.member.lastOwner');
-
-    const remove = await failure(
-      invoke(spaceRouter.revoke, { spaceId: SPACE_ID, userId: USER_ID }, ctx),
-    );
-    expect(remove.key).toBe('space.member.lastOwner');
-    expect(repos.users.revoke).not.toHaveBeenCalled();
-  });
-
-  it('lets an owner be demoted once another owner exists', async () => {
-    const ctx = stubContext();
-    const repos = mocks(ctx);
-    repos.users.roleIn!.mockResolvedValue('owner');
-    repos.users.membersOf!.mockResolvedValue([
-      { userId: USER_ID, role: 'owner' },
-      { userId: OTHER_USER_ID, role: 'owner' },
-    ]);
-
-    await invoke(spaceRouter.grant, { spaceId: SPACE_ID, userId: USER_ID, role: 'editor' }, ctx);
-    expect(repos.users.grant).toHaveBeenCalledWith(USER_ID, SPACE_ID, 'editor');
-  });
-
-  it('needs user:write in that space', async () => {
-    const ctx = stubContext({ principal: principal({ spaces: { [SPACE_ID]: 'editor' } }) });
-    const result = await failure(
-      invoke(spaceRouter.grant, { spaceId: SPACE_ID, userId: OTHER_USER_ID, role: 'viewer' }, ctx),
-    );
-    expect(result.code).toBe('FORBIDDEN');
-  });
-});
-
-describe('spaces.addMembers', () => {
-  it('skips users who are already members', async () => {
-    const ctx = stubContext();
-    const repos = mocks(ctx);
-    repos.users.membersOf!.mockResolvedValue([{ userId: OTHER_USER_ID, role: 'editor' }]);
-
-    const result = await invoke<{ added: number }>(
-      spaceRouter.addMembers,
-      { spaceId: SPACE_ID, userIds: [USER_ID, OTHER_USER_ID], role: 'viewer' },
-      ctx,
-    );
-    expect(result.added).toBe(1);
-    expect(repos.users.grant).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('spaces.setHome', () => {
-  it('rejects a document from another space', async () => {
-    const ctx = stubContext();
-    const repos = mocks(ctx);
-    repos.spaces.findById!.mockResolvedValue(space());
-    repos.content.findById!.mockResolvedValue({ id: 'x', spaceId: OTHER_SPACE_ID });
-
-    const result = await failure(
-      invoke(spaceRouter.setHome, { spaceId: SPACE_ID, contentId: OTHER_USER_ID }, ctx),
-    );
-    expect(result.key).toBe('content.notInSpace');
-  });
-});

package/test/user.test.ts

@@ -1,212 +0,0 @@
-import { describe, expect, it, type vi } from 'vitest';
-import { userRouter } from '../src/routers/user.js';
-import {
-  failure,
-  invoke,
-  mocks,
-  OTHER_USER_ID,
-  SPACE_ID,
-  stubContext,
-  superadmin,
-  TYPE_ID,
-  USER_ID,
-} from './helpers.js';
-
-const user = (overrides = {}) => ({
-  id: OTHER_USER_ID,
-  name: 'Sam',
-  email: 'sam@example.com',
-  emailVerified: false,
-  image: null,
-  role: 'editor',
-  banned: false,
-  banReason: null,
-  createdAt: new Date('2026-01-01'),
-  updatedAt: new Date('2026-01-01'),
-  ...overrides,
-});
-
-describe('users.setupNeeded', () => {
-  it('is public and true only while the instance has no account', async () => {
-    const ctx = stubContext({ principal: null });
-    const repos = mocks(ctx);
-    repos.users.count.mockResolvedValue(0);
-    expect(await invoke(userRouter.setupNeeded, undefined, ctx)).toEqual({ setupNeeded: true });
-    repos.users.count.mockResolvedValue(3);
-    expect(await invoke(userRouter.setupNeeded, undefined, ctx)).toEqual({ setupNeeded: false });
-  });
-});
-
-describe('users.list', () => {
-  it('is superadmin-only', async () => {
-    const result = await failure(invoke(userRouter.list, {}, stubContext()));
-    expect(result.code).toBe('FORBIDDEN');
-    expect(result.key).toBe('auth.superadminRequired');
-  });
-
-  it('strips the row down to a summary', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    mocks(ctx).users.list.mockResolvedValue({
-      items: [user()],
-      total: 1,
-      limit: 25,
-      offset: 0,
-    });
-    const page = await invoke<{ items: Record<string, unknown>[] }>(userRouter.list, {}, ctx);
-    expect(page.items[0]).not.toHaveProperty('emailVerified');
-    expect(page.items[0]).toMatchObject({ id: OTHER_USER_ID, email: 'sam@example.com' });
-  });
-});
-
-describe('users.create', () => {
-  it('hashes the password and normalises the email', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.users.create.mockImplementation(async (data) => user({ email: data.email }));
-
-    const created = await invoke<{ email: string }>(
-      userRouter.create,
-      { name: ' Sam ', email: 'Sam@Example.com', password: 'correct horse battery staple' },
-      ctx,
-    );
-
-    expect(created.email).toBe('sam@example.com');
-    const [data] = repos.users.create.mock.calls[0] as [Record<string, string>];
-    expect(data.name).toBe('Sam');
-    expect(data.role).toBe('editor');
-    expect(data.passwordHash).toMatch(/^\$argon2id\$/);
-    expect(data.passwordHash).not.toContain('correct horse');
-  });
-
-  it('refuses a short password before touching the database', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const result = await failure(
-      invoke(userRouter.create, { name: 'Sam', email: 'sam@example.com', password: 'short' }, ctx),
-    );
-    expect(result.code).toBe('BAD_REQUEST');
-    expect(mocks(ctx).users.create).not.toHaveBeenCalled();
-  });
-
-  it('turns a duplicate email into a validation error', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const violation = Object.assign(new Error('Failed query: insert into "users"'), {
-      cause: { code: '23505', message: 'duplicate key value violates "users_email_key"' },
-    });
-    mocks(ctx).users.create.mockRejectedValue(violation);
-    const result = await failure(
-      invoke(
-        userRouter.create,
-        { name: 'Sam', email: 'sam@example.com', password: 'correct horse battery staple' },
-        ctx,
-      ),
-    );
-    // The error is the validation envelope; the field-level key rides in its details.
-    expect(result.key).toBe('user.validation.failed');
-    expect(result.details?.[0]).toMatchObject({ key: 'user.email.taken', path: ['email'] });
-  });
-});
-
-describe('users.setRole', () => {
-  it('keeps the last superadmin', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.users.findById.mockResolvedValue(user({ id: USER_ID, role: 'superadmin' }));
-    repos.users.countByRole.mockResolvedValue(1);
-    const result = await failure(
-      invoke(userRouter.setRole, { userId: USER_ID, role: 'editor' }, ctx),
-    );
-    expect(result.key).toBe('user.lastSuperadmin');
-    expect(repos.users.setRole).not.toHaveBeenCalled();
-  });
-
-  it('demotes a superadmin when another remains', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.users.findById.mockResolvedValue(user({ role: 'superadmin' }));
-    repos.users.countByRole.mockResolvedValue(2);
-    repos.users.setRole.mockResolvedValue(user());
-    await invoke(userRouter.setRole, { userId: OTHER_USER_ID, role: 'editor' }, ctx);
-    expect(repos.users.setRole).toHaveBeenCalledWith(OTHER_USER_ID, 'editor');
-  });
-});
-
-describe('users.ban / users.delete', () => {
-  it('will not act on the caller', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    for (const procedure of [userRouter.ban, userRouter.delete]) {
-      const result = await failure(invoke(procedure, { userId: USER_ID }, ctx));
-      expect(result.key).toBe('user.self.protected');
-    }
-    expect(repos.users.setBanned).not.toHaveBeenCalled();
-    expect(repos.users.delete).not.toHaveBeenCalled();
-  });
-
-  it('bans and signs the account out everywhere', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.users.findById.mockResolvedValue(user());
-    repos.users.setBanned.mockResolvedValue(user({ banned: true, banReason: 'left' }));
-    const banned = await invoke<{ banned: boolean }>(
-      userRouter.ban,
-      { userId: OTHER_USER_ID, reason: 'left' },
-      ctx,
-    );
-    expect(banned.banned).toBe(true);
-    expect(repos.users.setBanned).toHaveBeenCalledWith(OTHER_USER_ID, true, 'left');
-    expect(repos.users.revokeSessions).toHaveBeenCalledWith(OTHER_USER_ID);
-  });
-
-  it('deletes an editor outright', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.users.findById.mockResolvedValue(user());
-    expect(await invoke(userRouter.delete, { userId: OTHER_USER_ID }, ctx)).toEqual({ ok: true });
-    expect(repos.users.delete).toHaveBeenCalledWith(OTHER_USER_ID);
-  });
-});
-
-describe('users.setPassword', () => {
-  it('stores a hash and revokes every session', async () => {
-    const ctx = stubContext({ principal: superadmin() });
-    const repos = mocks(ctx);
-    repos.users.findById.mockResolvedValue(user());
-    await invoke(
-      userRouter.setPassword,
-      { userId: OTHER_USER_ID, password: 'correct horse battery staple' },
-      ctx,
-    );
-    const [, hash] = repos.users.setPasswordHash.mock.calls[0] as [string, string];
-    expect(hash).toMatch(/^\$argon2id\$/);
-    expect(repos.users.revokeSessions).toHaveBeenCalledWith(OTHER_USER_ID);
-  });
-});
-
-describe('users.issueApiKey', () => {
-  it('stores a permission restriction it has checked, and refuses one it cannot', async () => {
-    const ctx = stubContext();
-    const apiKeys = ctx.apiKeys as unknown as { issue: ReturnType<typeof vi.fn> };
-    apiKeys.issue.mockResolvedValue({ id: 'k', name: 'site', key: 'mbx_x_y', prefix: 'x' });
-
-    await invoke(
-      userRouter.issueApiKey,
-      {
-        name: 'site',
-        spaceIds: [SPACE_ID],
-        permissions: ['content:read', `content:write:${TYPE_ID}`],
-      },
-      ctx,
-    );
-    expect(apiKeys.issue).toHaveBeenCalledWith(USER_ID, 'site', {
-      expiresAt: undefined,
-      spaceIds: [SPACE_ID],
-      permissions: ['content:read', `content:write:${TYPE_ID}`],
-    });
-
-    const refused = await failure(
-      invoke(userRouter.issueApiKey, { name: 'site', permissions: ['content:read:nowhere'] }, ctx),
-    );
-    expect(refused.key).toBe('apiKey.validation.failed');
-    expect(refused.details?.[0]?.path).toEqual(['permissions', 0]);
-  });
-});

package/test/workflow.test.ts

@@ -1,259 +0,0 @@
-import { ManabloxError } from '@manablox/core';
-import { describe, expect, it, vi } from 'vitest';
-import { workflowRouter } from '../src/routers/workflow.js';
-import { failure, invoke, principal, SPACE_ID, stubContext, USER_ID } from './helpers.js';
-
-const WORKFLOW_ID = '88888888-8888-4888-8888-888888888888';
-const CONTENT_ID = '99999999-9999-4999-8999-999999999999';
-
-function workflows() {
-  return {
-    catalog: vi.fn(),
-    list: vi.fn(),
-    get: vi.fn(),
-    create: vi.fn(),
-    update: vi.fn(),
-    setEnabled: vi.fn(),
-    delete: vi.fn(),
-    runs: vi.fn(),
-    run: vi.fn(),
-    runNow: vi.fn(),
-    subscriptions: vi.fn(),
-    subscribe: vi.fn(),
-    unsubscribe: vi.fn(),
-  };
-}
-
-const draft = () => ({
-  spaceId: SPACE_ID,
-  name: 'Ping',
-  trigger: { kind: 'event' as const, events: ['content.saved' as const] },
-  steps: [{ type: 'http' as const, url: 'https://example.test/hook' }],
-});
-
-describe('workflows.catalog', () => {
-  it('is open to any signed-in user and closed otherwise', async () => {
-    const service = workflows();
-    service.catalog.mockReturnValue({ events: [], steps: [], operators: [] });
-    const ctx = stubContext({ workflows: service as never, principal: principal({ spaces: {} }) });
-    expect(await invoke(workflowRouter.catalog, undefined, ctx)).toEqual({
-      events: [],
-      steps: [],
-      operators: [],
-    });
-    expect(
-      await failure(invoke(workflowRouter.catalog, undefined, { ...ctx, principal: null })),
-    ).toMatchObject({ code: 'UNAUTHORIZED' });
-  });
-});
-
-describe('workflows.list / get', () => {
-  it('needs workflow:read, which an editor holds and a viewer lacks', async () => {
-    const service = workflows();
-    service.list.mockResolvedValue([]);
-    const ctx = stubContext({
-      workflows: service as never,
-      principal: principal({ spaces: { [SPACE_ID]: 'editor' } }),
-    });
-    expect(await invoke(workflowRouter.list, { spaceId: SPACE_ID }, ctx)).toEqual([]);
-    expect(service.list).toHaveBeenCalledWith(SPACE_ID);
-    const viewer = { ...ctx, principal: principal({ spaces: { [SPACE_ID]: 'viewer' } }) };
-    expect(await failure(invoke(workflowRouter.list, { spaceId: SPACE_ID }, viewer))).toMatchObject(
-      { code: 'FORBIDDEN' },
-    );
-  });
-
-  it('maps a missing workflow to NOT_FOUND', async () => {
-    const service = workflows();
-    service.get.mockRejectedValue(ManabloxError.notFound('workflow.notFound', { id: WORKFLOW_ID }));
-    const ctx = stubContext({ workflows: service as never });
-    expect(
-      await failure(invoke(workflowRouter.get, { spaceId: SPACE_ID, id: WORKFLOW_ID }, ctx)),
-    ).toMatchObject({ code: 'NOT_FOUND', key: 'workflow.notFound' });
-  });
-});
-
-describe('workflows.create / update', () => {
-  it('needs workflow:write, which an editor lacks and an admin holds', async () => {
-    const service = workflows();
-    service.create.mockResolvedValue({ id: WORKFLOW_ID });
-
-    const editor = stubContext({
-      workflows: service as never,
-      principal: principal({ spaces: { [SPACE_ID]: 'editor' } }),
-    });
-    expect(await failure(invoke(workflowRouter.create, draft(), editor))).toMatchObject({
-      code: 'FORBIDDEN',
-    });
-
-    const admin = stubContext({
-      workflows: service as never,
-      principal: principal({ spaces: { [SPACE_ID]: 'admin' } }),
-    });
-    expect(await invoke(workflowRouter.create, draft(), admin)).toEqual({ id: WORKFLOW_ID });
-  });
-
-  it('fills in every step and trigger default so the service sees the whole shape', async () => {
-    const service = workflows();
-    service.create.mockResolvedValue({ id: WORKFLOW_ID });
-    const ctx = stubContext({ workflows: service as never });
-    await invoke(workflowRouter.create, draft(), ctx);
-
-    const [spaceId, data] = service.create.mock.calls[0] as [string, Record<string, unknown>];
-    expect(spaceId).toBe(SPACE_ID);
-    expect(data.spaceId).toBeUndefined();
-    expect(data.trigger).toEqual({
-      kind: 'event',
-      events: ['content.saved'],
-      typeIds: [],
-      locales: [],
-    });
-    expect(data.steps).toEqual([
-      {
-        id: '',
-        name: '',
-        enabled: true,
-        continueOnError: false,
-        type: 'http',
-        method: 'POST',
-        url: 'https://example.test/hook',
-        headers: [],
-        body: { mode: 'event', template: '' },
-        secret: null,
-        timeoutMs: 10_000,
-      },
-    ]);
-  });
-
-  it('accepts a fork whose sides carry steps of their own', async () => {
-    const service = workflows();
-    service.update.mockResolvedValue({ id: WORKFLOW_ID });
-    const ctx = stubContext({ workflows: service as never });
-    await invoke(
-      workflowRouter.update,
-      {
-        ...draft(),
-        id: WORKFLOW_ID,
-        steps: [
-          {
-            type: 'branch',
-            rules: [{ field: 'content.status', operator: 'equals', value: 'published' }],
-            then: [{ type: 'delay', minutes: 5 }],
-          },
-        ],
-      },
-      ctx,
-    );
-    const [, , data] = service.update.mock.calls[0] as [string, string, { steps: unknown[] }];
-    expect(data.steps[0]).toMatchObject({
-      type: 'branch',
-      match: 'all',
-      then: [{ type: 'delay', minutes: 5, enabled: true }],
-      else: [],
-    });
-  });
-
-  it('refuses an unknown event and an unknown step type before the service', async () => {
-    const service = workflows();
-    const ctx = stubContext({ workflows: service as never });
-    expect(
-      (
-        await failure(
-          invoke(
-            workflowRouter.create,
-            { ...draft(), trigger: { kind: 'event', events: ['content.exploded'] } },
-            ctx,
-          ),
-        )
-      ).code,
-    ).toBe('BAD_REQUEST');
-    expect(
-      (await failure(invoke(workflowRouter.create, { ...draft(), steps: [{ type: 'fax' }] }, ctx)))
-        .code,
-    ).toBe('BAD_REQUEST');
-    expect(service.create).not.toHaveBeenCalled();
-  });
-
-  it('maps a service validation error to BAD_REQUEST with the step path', async () => {
-    const service = workflows();
-    service.create.mockRejectedValue(
-      ManabloxError.validation(
-        [{ key: 'workflow.step.http.url.invalid', path: ['steps', 0, 'url'] }],
-        'workflow.validation.failed',
-      ),
-    );
-    const ctx = stubContext({ workflows: service as never });
-    expect(await failure(invoke(workflowRouter.create, draft(), ctx))).toMatchObject({
-      code: 'BAD_REQUEST',
-      key: 'workflow.validation.failed',
-      details: [{ path: ['steps', 0, 'url'] }],
-    });
-  });
-});
-
-describe('workflows.setEnabled / delete / runNow', () => {
-  it('routes each to its service call with workflow:write', async () => {
-    const service = workflows();
-    service.setEnabled.mockResolvedValue({ id: WORKFLOW_ID, enabled: true });
-    service.delete.mockResolvedValue(undefined);
-    service.runNow.mockResolvedValue({ id: 'run' });
-    const ctx = stubContext({ workflows: service as never });
-
-    await invoke(
-      workflowRouter.setEnabled,
-      { spaceId: SPACE_ID, id: WORKFLOW_ID, enabled: true },
-      ctx,
-    );
-    expect(service.setEnabled).toHaveBeenCalledWith(SPACE_ID, WORKFLOW_ID, true);
-
-    expect(
-      await invoke(workflowRouter.delete, { spaceId: SPACE_ID, id: WORKFLOW_ID }, ctx),
-    ).toEqual({ ok: true });
-
-    await invoke(workflowRouter.runNow, { spaceId: SPACE_ID, id: WORKFLOW_ID }, ctx);
-    expect(service.runNow).toHaveBeenCalledWith(SPACE_ID, WORKFLOW_ID, null);
-    await invoke(
-      workflowRouter.runNow,
-      { spaceId: SPACE_ID, id: WORKFLOW_ID, contentId: CONTENT_ID },
-      ctx,
-    );
-    expect(service.runNow).toHaveBeenLastCalledWith(SPACE_ID, WORKFLOW_ID, CONTENT_ID);
-  });
-
-  it('lets an editor read runs but not start one', async () => {
-    const service = workflows();
-    service.runs.mockResolvedValue([]);
-    const ctx = stubContext({
-      workflows: service as never,
-      principal: principal({ spaces: { [SPACE_ID]: 'editor' } }),
-    });
-    await invoke(workflowRouter.runs, { spaceId: SPACE_ID, id: WORKFLOW_ID }, ctx);
-    expect(service.runs).toHaveBeenCalledWith(SPACE_ID, WORKFLOW_ID, 50);
-    expect(
-      await failure(invoke(workflowRouter.runNow, { spaceId: SPACE_ID, id: WORKFLOW_ID }, ctx)),
-    ).toMatchObject({ code: 'FORBIDDEN' });
-  });
-});
-
-describe('push subscriptions', () => {
-  it('are always the caller’s own, whatever the input says', async () => {
-    const service = workflows();
-    service.subscriptions.mockResolvedValue([]);
-    service.subscribe.mockResolvedValue({ endpoint: 'https://push.example/1' });
-    service.unsubscribe.mockResolvedValue(undefined);
-    const headers = new Headers({ 'user-agent': 'Test/1.0' });
-    const ctx = stubContext({ workflows: service as never, headers });
-
-    await invoke(workflowRouter.pushSubscriptions, undefined, ctx);
-    expect(service.subscriptions).toHaveBeenCalledWith(USER_ID);
-
-    const subscription = { endpoint: 'https://push.example/1', keys: { p256dh: 'p', auth: 'a' } };
-    await invoke(workflowRouter.pushSubscribe, subscription, ctx);
-    expect(service.subscribe).toHaveBeenCalledWith(USER_ID, subscription, 'Test/1.0');
-
-    expect(
-      await invoke(workflowRouter.pushUnsubscribe, { endpoint: subscription.endpoint }, ctx),
-    ).toEqual({ ok: true });
-    expect(service.unsubscribe).toHaveBeenCalledWith(USER_ID, subscription.endpoint);
-  });
-});

package/tsconfig.json

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

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['test/**/*.test.ts'],
-  },
-});