@manablox/db 0.1.0 → 0.2.0

package/migrations/meta/_journal.json

@@ -36,6 +36,34 @@
       "when": 1788544039067,
       "tag": "0004_apikey-spaces",
       "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "7",
+      "when": 1788598393872,
+      "tag": "0005_menus",
+      "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "7",
+      "when": 1788636583704,
+      "tag": "0006_roles",
+      "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "7",
+      "when": 1788639562448,
+      "tag": "0007_apikey-permissions",
+      "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1788650538612,
+      "tag": "0008_workflows",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manablox/db",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "exports": {
     ".": {
@@ -8,14 +8,18 @@
       "default": "./src/index.ts"
     },
     "./schema": {
-      "types": "./src/schema.ts",
-      "default": "./src/schema.ts"
+      "types": "./src/schema/index.ts",
+      "default": "./src/schema/index.ts"
+    },
+    "./testing": {
+      "types": "./src/testing.ts",
+      "default": "./src/testing.ts"
     }
   },
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "dependencies": {
-    "@manablox/core": "0.1.0",
+    "@manablox/core": "0.2.0",
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.9"
   },
@@ -32,6 +36,7 @@
     "generate": "drizzle-kit generate",
     "migrate": "tsx src/cli/migrate.ts",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run",
+    "create-db": "tsx src/cli/create-db.ts"
   }
 }

package/src/cli/create-db.ts

@@ -0,0 +1,30 @@
+import postgres from 'postgres';
+import { withDatabase } from '../testing.js';
+
+/**
+ * Creates the database `DATABASE_URL` names, on the server it names, if it does not
+ * exist — `--fresh` drops it first. For throwaway databases (the end-to-end run) where
+ * nothing else provisions them.
+ */
+const url = process.env.DATABASE_URL;
+if (!url) {
+  console.error('DATABASE_URL is required');
+  process.exit(1);
+}
+
+const name = new URL(url).pathname.replace(/^\//, '');
+const fresh = process.argv.includes('--fresh');
+const admin = postgres(withDatabase(url, 'postgres'), { max: 1 });
+
+try {
+  if (fresh) await admin.unsafe(`drop database if exists "${name}" with (force)`);
+  const [row] = await admin.unsafe(`select 1 as found from pg_database where datname = '${name}'`);
+  if (!row) {
+    await admin.unsafe(`create database "${name}"`);
+    console.info(`created database ${name}`);
+  } else {
+    console.info(`database ${name} exists`);
+  }
+} finally {
+  await admin.end();
+}

package/src/cli/migrate.ts

@@ -1,10 +1,5 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { migrate } from 'drizzle-orm/postgres-js/migrator';
-import { applyBootstrapSql } from '../bootstrap.js';
 import { createDatabase } from '../client.js';
-
-const migrationsFolder = resolve(dirname(fileURLToPath(import.meta.url)), '../../migrations');
+import { runMigrations } from '../migrate.js';
 
 const url = process.env.DATABASE_URL;
 if (!url) {
@@ -15,9 +10,7 @@ if (!url) {
 const handle = createDatabase({ url, max: 1 });
 
 try {
-  // Extensions must exist before the generated migrations reference ltree columns.
-  await applyBootstrapSql(handle.sql);
-  await migrate(handle.db, { migrationsFolder });
+  await runMigrations(handle);
   console.info('migrations applied');
 } finally {
   await handle.close();

package/src/client.ts

@@ -1,9 +1,16 @@
 import type { DatabaseConfig } from '@manablox/core';
 import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import postgres from 'postgres';
-import * as schema from './schema.js';
+import * as schema from './schema/index.js';
 
 export type Database = PostgresJsDatabase<typeof schema>;
+/** What `db.transaction((tx) => …)` hands its callback. */
+export type Transaction = Parameters<Parameters<Database['transaction']>[0]>[0];
+/**
+ * Anything a query can run on. Repository internals take this so the same helper serves
+ * a call inside a transaction and one outside it, without casting `tx` to `Database`.
+ */
+export type Executor = Database | Transaction;
 export type Sql = ReturnType<typeof postgres>;
 
 export interface DatabaseHandle {

package/src/errors.ts

@@ -0,0 +1,50 @@
+import { type ErrorDetail, type ErrorKey, ManabloxError } from '@manablox/core';
+
+/**
+ * Postgres reports a unique-constraint violation as SQLSTATE `23505` with the constraint
+ * name in the message. Drizzle wraps the driver error, so the code and the message sit on
+ * `cause`, while the outer message is only ever "Failed query: insert into …".
+ */
+export function isUniqueViolation(error: unknown, constraint: string): boolean {
+  const cause = (error as { cause?: { code?: string; message?: string } })?.cause;
+  const code = (error as { code?: string })?.code ?? cause?.code;
+  const detail = `${cause?.message ?? ''} ${(error as { message?: string })?.message ?? ''}`;
+  return code === '23505' && detail.includes(constraint);
+}
+
+export interface UniqueViolationMapping {
+  /** The constraint name, or a distinctive part of it. */
+  constraint: string;
+  /** The detail reported for the field, e.g. `content.slug.duplicate`. */
+  key: ErrorKey;
+  path?: (string | number)[];
+  params?: Record<string, unknown>;
+  /** The error's own key. */
+  errorKey: ErrorKey;
+}
+
+/**
+ * Turns a unique violation on one constraint into the validation error the client would
+ * have received had the check run before the write, and rethrows anything else untouched.
+ * Use as `.catch((error) => rethrowUniqueViolation(error, { … }))`.
+ */
+export function rethrowUniqueViolation(error: unknown, mapping: UniqueViolationMapping): never {
+  if (!isUniqueViolation(error, mapping.constraint)) throw error;
+
+  const detail: ErrorDetail = {
+    key: mapping.key,
+    ...(mapping.path ? { path: mapping.path } : {}),
+    ...(mapping.params ? { params: mapping.params } : {}),
+  };
+  throw ManabloxError.validation([detail], mapping.errorKey);
+}
+
+/**
+ * A preset for one constraint: `const taken = uniqueViolation({ … })` once beside the
+ * service, then `.catch(taken({ machineName }))` on every write that can trip it. The
+ * params are the only part that differs per call, so they are the only argument left.
+ */
+export function uniqueViolation(preset: Omit<UniqueViolationMapping, 'params'>) {
+  return (params: Record<string, unknown>) => (error: unknown) =>
+    rethrowUniqueViolation(error, { ...preset, params });
+}

package/src/index.ts

@@ -1,13 +1,19 @@
 export * from './bootstrap.js';
 export * from './client.js';
 export * from './columns.js';
+export * from './errors.js';
+export * from './migrate.js';
+export * from './pagination.js';
 export * from './query.js';
 export * from './repositories/asset.js';
 export * from './repositories/asset-usage.js';
 export * from './repositories/content.js';
 export * from './repositories/content-type.js';
 export * from './repositories/index.js';
+export * from './repositories/menu.js';
 export * from './repositories/space.js';
 export * from './repositories/user.js';
-export * as schema from './schema.js';
-export * from './schema.js';
+export * from './repositories/webhook.js';
+export * from './repositories/workflow.js';
+export * as schema from './schema/index.js';
+export * from './schema/index.js';

package/src/migrate.ts

@@ -0,0 +1,21 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { migrate } from 'drizzle-orm/postgres-js/migrator';
+import { applyBootstrapSql } from './bootstrap.js';
+import type { DatabaseHandle } from './client.js';
+
+/** The SQL files shipped with this package, next to `src/`. */
+export const MIGRATIONS_FOLDER = resolve(dirname(fileURLToPath(import.meta.url)), '../migrations');
+
+/**
+ * Brings a database up to the schema this version of the package expects.
+ *
+ * The same call the compose stack's `migrate` service and the `manablox migrate` CLI
+ * make, so an instance run from a dependency and one run from the repository apply the
+ * same files in the same order. Idempotent: drizzle records what it has applied.
+ */
+export async function runMigrations(handle: DatabaseHandle): Promise<void> {
+  // Extensions must exist before the generated migrations reference ltree columns.
+  await applyBootstrapSql(handle.sql);
+  await migrate(handle.db, { migrationsFolder: MIGRATIONS_FOLDER });
+}

package/src/pagination.ts

@@ -0,0 +1,52 @@
+import { getTableColumns, type SQL, sql } from 'drizzle-orm';
+import type { PgColumn, PgTable } from 'drizzle-orm/pg-core';
+import type { Executor } from './client.js';
+import type { Pagination } from './query.js';
+
+export interface Paginated<T> {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+
+/**
+ * One page of a table plus the total, in one round trip: a window `count(*) over ()`
+ * rides along with the rows. A page past the end comes back empty and so carries no
+ * count; only then is the total asked for separately, so a caller paging by `total`
+ * still learns the true size.
+ */
+export async function paginate<TTable extends PgTable>(
+  db: Executor,
+  table: TTable,
+  options: {
+    where?: SQL | undefined;
+    orderBy: SQL | PgColumn | (SQL | PgColumn)[];
+    pagination: Pagination;
+  },
+): Promise<Paginated<TTable['$inferSelect']>> {
+  const orderBy = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+  const rows = (await db
+    .select({ ...getTableColumns(table), total: sql<number>`count(*) over ()::int` })
+    .from(table as PgTable)
+    .where(options.where)
+    .orderBy(...orderBy)
+    .limit(options.pagination.limit)
+    .offset(options.pagination.offset)) as Array<TTable['$inferSelect'] & { total: number }>;
+
+  let total = rows[0]?.total ?? 0;
+  if (rows.length === 0 && options.pagination.offset > 0) {
+    const counted = await db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(table as PgTable)
+      .where(options.where);
+    total = counted[0]?.count ?? 0;
+  }
+
+  return {
+    items: rows.map(({ total: _total, ...row }) => row as TTable['$inferSelect']),
+    total,
+    limit: options.pagination.limit,
+    offset: options.pagination.offset,
+  };
+}

package/src/query.ts

@@ -1,7 +1,7 @@
 import { type ContentTypeRegistry, type FilterOperator, ManabloxError } from '@manablox/core';
 import { and, eq, inArray, isNull, type SQL, sql } from 'drizzle-orm';
 import type { PgColumn } from 'drizzle-orm/pg-core';
-import type { contents, publishedContents } from './schema.js';
+import type { contents, publishedContents } from './schema/index.js';
 
 /**
  * Both content tables share a column set, so one filter builder serves the draft and
@@ -38,7 +38,6 @@ export interface ContentFilter {
   slug?: string | undefined;
   permalink?: string | undefined;
   localizationId?: string | undefined;
-  visibleInMenu?: boolean | undefined;
   /** Full-text query against `title` + field contributions. */
   search?: string | undefined;
   fields?: FieldFilter[] | undefined;
@@ -81,9 +80,6 @@ export function buildContentWhere(
   if (filter.localizationId) conditions.push(eq(table.localizationId, filter.localizationId));
   if (filter.slug) conditions.push(eq(table.slug, filter.slug));
   if (filter.permalink !== undefined) conditions.push(eq(table.permalink, filter.permalink));
-  if (filter.visibleInMenu !== undefined) {
-    conditions.push(eq(table.visibleInMenu, filter.visibleInMenu));
-  }
   if (filter.typeIds?.length) conditions.push(inArray(table.typeId, filter.typeIds));
   if (filter.ids?.length) conditions.push(inArray(table.id, filter.ids));
 

package/src/repositories/asset-usage.ts

@@ -1,6 +1,6 @@
 import { and, eq, inArray, notInArray, sql } from 'drizzle-orm';
 import type { Database } from '../client.js';
-import { assetUsages, contents, publishedContents } from '../schema.js';
+import { assetUsages, contents, publishedContents } from '../schema/index.js';
 
 /**
  * The asset → document reachability index.

package/src/repositories/asset.ts

@@ -1,8 +1,9 @@
 import { type Loose, ManabloxError } from '@manablox/core';
 import { and, desc, eq, inArray, sql } from 'drizzle-orm';
 import type { Database } from '../client.js';
-import { type AssetRow, type AssetVariantRow, assets, assetVariants } from '../schema.js';
-import type { Paginated, Pagination } from './content.js';
+import { type Paginated, paginate } from '../pagination.js';
+import type { Pagination } from '../query.js';
+import { type AssetRow, type AssetVariantRow, assets, assetVariants } from '../schema/index.js';
 
 export interface AssetWriteData {
   id?: string | undefined;
@@ -69,25 +70,11 @@ export class AssetRepository {
       );
     }
 
-    const where = and(...conditions);
-
-    const [items, counted] = await Promise.all([
-      this.db
-        .select()
-        .from(assets)
-        .where(where)
-        .orderBy(desc(assets.createdAt))
-        .limit(pagination.limit)
-        .offset(pagination.offset),
-      this.db.select({ count: sql<number>`count(*)::int` }).from(assets).where(where),
-    ]);
-
-    return {
-      items,
-      total: counted[0]?.count ?? 0,
-      limit: pagination.limit,
-      offset: pagination.offset,
-    };
+    return paginate(this.db, assets, {
+      where: and(...conditions),
+      orderBy: desc(assets.createdAt),
+      pagination,
+    });
   }
 
   async create(data: AssetWriteData): Promise<AssetRow> {
@@ -158,6 +145,11 @@ export class AssetRepository {
     return rows[0] ?? null;
   }
 
+  /** Drops every variant row; the caller removes the files. */
+  async deleteVariants(assetId: string): Promise<void> {
+    await this.db.delete(assetVariants).where(eq(assetVariants.assetId, assetId));
+  }
+
   async addVariant(data: {
     assetId: string;
     preset: string;

package/src/repositories/content-type.ts

@@ -6,7 +6,7 @@ import {
 } from '@manablox/core';
 import { eq } from 'drizzle-orm';
 import type { Database } from '../client.js';
-import { type ContentTypeRow, contentTypes } from '../schema.js';
+import { type ContentTypeRow, contentTypes } from '../schema/index.js';
 
 /**
  * Persistence for *runtime-defined* content types only. Code-defined types come from