@manablox/db 0.2.0 → 0.3.0

package/src/schema/workflows.ts

@@ -1,92 +0,0 @@
-import type {
-  WorkflowCursor,
-  WorkflowRunContext,
-  WorkflowRunStatus,
-  WorkflowStep,
-  WorkflowStepLog,
-  WorkflowTrigger,
-} from '@manablox/core';
-import { sql } from 'drizzle-orm';
-import { boolean, index, jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
-import { users } from './auth.js';
-import { spaces } from './spaces.js';
-
-/**
- * A workflow: something that happens when content changes, or on a schedule. The
- * trigger and the steps are documents rather than rows — a workflow is edited and saved
- * as one thing, and a step type added later needs no migration.
- */
-export const workflows = pgTable(
-  'workflows',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    name: text().notNull(),
-    description: text(),
-    enabled: boolean().notNull().default(false),
-    trigger: jsonb().$type<WorkflowTrigger>().notNull(),
-    steps: jsonb().$type<WorkflowStep[]>().notNull().default(sql`'[]'::jsonb`),
-    /**
-     * The minute a scheduled workflow was last claimed for, so two processes ticking at
-     * once start one run between them rather than one each.
-     */
-    lastScheduledAt: timestamp({ withTimezone: true }),
-    lastRunAt: timestamp({ withTimezone: true }),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [index('workflows_space_idx').on(table.spaceId, table.enabled)],
-);
-
-/**
- * One execution of a workflow, with everything needed to continue it after a pause: the
- * context the templates read, the index of the next step and the log so far.
- */
-export const workflowRuns = pgTable(
-  'workflow_runs',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    workflowId: uuid()
-      .notNull()
-      .references(() => workflows.id, { onDelete: 'cascade' }),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    /** The event name, or `schedule` / `manual`. */
-    trigger: text().notNull(),
-    status: text().$type<WorkflowRunStatus>().notNull().default('queued'),
-    context: jsonb().$type<WorkflowRunContext>().notNull(),
-    /** Where to continue; a paused run resumes here. See `WorkflowCursor`. */
-    cursor: jsonb().$type<WorkflowCursor>().notNull().default(sql`'[]'::jsonb`),
-    log: jsonb().$type<WorkflowStepLog[]>().notNull().default(sql`'[]'::jsonb`),
-    error: text(),
-    /** Set while `waiting`: when the scheduler should pick the run up again. */
-    resumeAt: timestamp({ withTimezone: true }),
-    startedAt: timestamp({ withTimezone: true }),
-    finishedAt: timestamp({ withTimezone: true }),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    index('workflow_runs_workflow_idx').on(table.workflowId, table.createdAt),
-    index('workflow_runs_resume_idx').on(table.status, table.resumeAt),
-  ],
-);
-
-/** A browser a user allowed push notifications in; one row per device. */
-export const pushSubscriptions = pgTable(
-  'push_subscriptions',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    userId: uuid()
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    endpoint: text().notNull().unique('push_subscriptions_endpoint_key'),
-    keys: jsonb().$type<{ p256dh: string; auth: string }>().notNull(),
-    userAgent: text(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    lastUsedAt: timestamp({ withTimezone: true }),
-  },
-  (table) => [index('push_subscriptions_user_idx').on(table.userId)],
-);

package/src/testing-fixtures.ts

@@ -1,139 +0,0 @@
-/**
- * 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.
- */
-import {
-  type ContentTypeDefinition,
-  ContentTypeRegistry,
-  defineContentType,
-  defineFieldType,
-  FieldTypeRegistry,
-  type StandardSchemaV1,
-} from '@manablox/core';
-import { createDatabase, type DatabaseHandle } from './client.js';
-import { createRepositories, type Repositories } from './repositories/index.js';
-import { createTestDatabase } from './testing.js';
-
-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 RepositoryTestContext {
-  handle: DatabaseHandle;
-  /** Every statement sent to Postgres, so a test can assert what a call cost. */
-  queries: string[];
-  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 createRepositoryContext(name: string): Promise<RepositoryTestContext> {
-  const database = await createTestDatabase(name);
-  const queries: string[] = [];
-  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' },
-    ],
-  });
-  // 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,
-    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. */
-export async function makeNode(
-  ctx: RepositoryTestContext,
-  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/src/testing.ts

@@ -1,105 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readdirSync, readFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { migrate } from 'drizzle-orm/postgres-js/migrator';
-import postgres from 'postgres';
-import { applyBootstrapSql } from './bootstrap.js';
-import { createDatabase } from './client.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.
- */
-export 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(): string {
-  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: postgres.Sql): Promise<void> {
-  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}'))`);
-  }
-}
-
-export function withDatabase(url: string, name: string): string {
-  return url.replace(/\/[^/?]*(\?.*)?$/, `/${name}$1`);
-}
-
-export interface TestDatabase {
-  name: string;
-  url: string;
-  /** Drops the database. Safe to call once every connection to it is closed. */
-  drop: () => Promise<void>;
-}
-
-/**
- * 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.
- */
-export async function createTestDatabase(prefix: string): Promise<TestDatabase> {
-  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();
-      }
-    },
-  };
-}
-
-export * from './testing-fixtures.js';

package/test/asset-usage.test.ts

@@ -1,101 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { createRepositoryContext, makeNode, type RepositoryTestContext } from '../src/testing.js';
-
-let ctx: RepositoryTestContext;
-let assetA: string;
-let assetB: string;
-
-beforeAll(async () => {
-  ctx = await createRepositoryContext('asset_usage');
-  assetA = (await createAsset('a.jpg')).id;
-  assetB = (await createAsset('b.jpg')).id;
-});
-afterAll(async () => {
-  await ctx?.close();
-});
-
-const createAsset = (filename: string) =>
-  ctx.repos.assets.create({
-    spaceId: ctx.spaceId,
-    driver: 'local',
-    key: `k/${filename}`,
-    filename,
-    name: filename,
-    mimeType: 'image/jpeg',
-    size: 10,
-  });
-
-const published = (ids: string[]) => ctx.repos.assetUsages.filterPublished(ids);
-
-describe('asset reachability', () => {
-  it('a draft reference does not make an asset public', async () => {
-    const node = await makeNode(ctx, { title: 'Draft', slug: 'draft' });
-    await ctx.repos.assetUsages.recordDraft(node.id, ctx.spaceId, [assetA]);
-
-    expect([...(await published([assetA]))]).toEqual([]);
-    expect(await ctx.repos.assetUsages.forContent(node.id)).toEqual([
-      { assetId: assetA, published: false },
-    ]);
-  });
-
-  it('publishing makes exactly the referenced assets public', async () => {
-    const node = await makeNode(ctx, { title: 'Live', slug: 'live' });
-    await ctx.repos.assetUsages.recordDraft(node.id, ctx.spaceId, [assetA, assetB]);
-    await ctx.repos.assetUsages.recordPublished(node.id, ctx.spaceId, [assetA]);
-
-    const reachable = await published([assetA, assetB]);
-    expect(reachable.has(assetA)).toBe(true);
-    expect(reachable.has(assetB)).toBe(false);
-  });
-
-  it('editing a draft does not revoke an asset the live page still shows', async () => {
-    const node = await makeNode(ctx, { title: 'Edited', slug: 'edited' });
-    await ctx.repos.assetUsages.recordPublished(node.id, ctx.spaceId, [assetA]);
-
-    // The editor removes the image from the draft but has not published yet.
-    await ctx.repos.assetUsages.recordDraft(node.id, ctx.spaceId, []);
-
-    expect((await published([assetA])).has(assetA)).toBe(true);
-  });
-
-  it('unpublishing the only referencing document revokes the asset', async () => {
-    const asset = (await createAsset('lonely.jpg')).id;
-    const node = await makeNode(ctx, { title: 'Lonely', slug: 'lonely' });
-
-    await ctx.repos.assetUsages.recordPublished(node.id, ctx.spaceId, [asset]);
-    expect((await published([asset])).has(asset)).toBe(true);
-
-    await ctx.repos.assetUsages.clearPublished(node.id);
-    expect((await published([asset])).has(asset)).toBe(false);
-  });
-
-  it('keeps an asset public while any other published document references it', async () => {
-    const asset = (await createAsset('shared.jpg')).id;
-    const one = await makeNode(ctx, { title: 'One', slug: 'one' });
-    const two = await makeNode(ctx, { title: 'Two', slug: 'two' });
-
-    await ctx.repos.assetUsages.recordPublished(one.id, ctx.spaceId, [asset]);
-    await ctx.repos.assetUsages.recordPublished(two.id, ctx.spaceId, [asset]);
-
-    await ctx.repos.assetUsages.clearPublished(one.id);
-    expect((await published([asset])).has(asset)).toBe(true);
-  });
-
-  it('republishing without an asset revokes it', async () => {
-    const asset = (await createAsset('dropped.jpg')).id;
-    const node = await makeNode(ctx, { title: 'Dropped', slug: 'dropped' });
-
-    await ctx.repos.assetUsages.recordPublished(node.id, ctx.spaceId, [asset]);
-    await ctx.repos.assetUsages.recordPublished(node.id, ctx.spaceId, []);
-
-    expect((await published([asset])).has(asset)).toBe(false);
-  });
-
-  it('drops every usage when the document is deleted', async () => {
-    const node = await makeNode(ctx, { title: 'Doomed', slug: 'doomed' });
-    await ctx.repos.assetUsages.recordPublished(node.id, ctx.spaceId, [assetA, assetB]);
-
-    await ctx.repos.assetUsages.deleteForContent(node.id);
-    expect(await ctx.repos.assetUsages.forContent(node.id)).toEqual([]);
-  });
-});

package/test/menu.test.ts

@@ -1,126 +0,0 @@
-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'),
-    );
-  });
-});