@manablox/db 0.2.0 → 0.4.0

package/migrations/meta/_journal.json

@@ -64,6 +64,20 @@
       "when": 1788650538612,
       "tag": "0008_workflows",
       "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "7",
+      "when": 1788692313004,
+      "tag": "0009_audit-log",
+      "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "7",
+      "when": 1788722093611,
+      "tag": "0010_notifications-approvals",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@manablox/db",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./schema": {
-      "types": "./src/schema/index.ts",
-      "default": "./src/schema/index.ts"
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.js"
     },
     "./testing": {
-      "types": "./src/testing.ts",
-      "default": "./src/testing.ts"
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
     }
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "dependencies": {
-    "@manablox/core": "0.2.0",
+    "@manablox/core": "0.4.0",
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.9"
   },
@@ -28,11 +28,19 @@
     "@types/node": "^26.4.1",
     "drizzle-kit": "^0.31.10",
     "testcontainers": "^12.1.0",
+    "tsdown": "^0.23.0",
     "tsx": "^4.20.7",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"
   },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "migrations",
+    "README.md"
+  ],
   "scripts": {
+    "build": "tsdown",
     "generate": "drizzle-kit generate",
     "migrate": "tsx src/cli/migrate.ts",
     "typecheck": "tsc --noEmit",

package/drizzle.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-  schema: './src/schema/index.ts',
-  out: './migrations',
-  dialect: 'postgresql',
-  dbCredentials: {
-    url: process.env.DATABASE_URL ?? 'postgres://manablox:manablox@localhost:5432/manablox',
-  },
-  casing: 'snake_case',
-});

package/src/bootstrap.ts

@@ -1,13 +0,0 @@
-import type { Sql } from './client.js';
-
-/**
- * Extensions the schema depends on. Run before the generated migrations, which
- * reference `ltree` columns and `pg_trgm` operator classes.
- */
-export async function applyBootstrapSql(sql: Sql): Promise<void> {
-  await sql.unsafe(`
-    create extension if not exists "ltree";
-    create extension if not exists "pg_trgm";
-    create extension if not exists "btree_gin";
-  `);
-}

package/src/cli/create-db.ts

@@ -1,30 +0,0 @@
-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,17 +0,0 @@
-import { createDatabase } from '../client.js';
-import { runMigrations } from '../migrate.js';
-
-const url = process.env.DATABASE_URL;
-if (!url) {
-  console.error('DATABASE_URL is required');
-  process.exit(1);
-}
-
-const handle = createDatabase({ url, max: 1 });
-
-try {
-  await runMigrations(handle);
-  console.info('migrations applied');
-} finally {
-  await handle.close();
-}

package/src/client.ts

@@ -1,44 +0,0 @@
-import type { DatabaseConfig } from '@manablox/core';
-import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
-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 {
-  db: Database;
-  sql: Sql;
-  close: () => Promise<void>;
-}
-
-export interface DatabaseOptions {
-  /** Called once per statement sent to Postgres. Used by tests to assert query counts. */
-  onQuery?: (query: string) => void;
-}
-
-export function createDatabase(
-  config: DatabaseConfig,
-  options: DatabaseOptions = {},
-): DatabaseHandle {
-  const sql = postgres(config.url, {
-    max: config.max ?? 10,
-    ...(options.onQuery ? { debug: (_c: number, query: string) => options.onQuery?.(query) } : {}),
-    ...(config.ssl ? { ssl: 'require' as const } : {}),
-    // `ltree` and `tsvector` have no client-side parser, so postgres.js returns them as
-    // strings — which is exactly what the schema declares. Do not pass `types: {}` here:
-    // it replaces the built-in serialisers wholesale and Date parameters stop working.
-    onnotice: () => {},
-  });
-
-  const db = drizzle(sql, { schema, casing: 'snake_case' });
-
-  return { db, sql, close: () => sql.end({ timeout: 5 }) };
-}

package/src/columns.ts

@@ -1,39 +0,0 @@
-import { customType } from 'drizzle-orm/pg-core';
-
-/**
- * `ltree` — the materialised ancestor path of a content node. A subtree move is one
- * `UPDATE ... SET path = :newParent || subpath(path, nlevel(:oldParent))`.
- */
-export const ltree = customType<{ data: string; driverData: string }>({
-  dataType: () => 'ltree',
-});
-
-/** `tsvector` — generated from `title` + `search_text`, never written directly. */
-export const tsvector = customType<{ data: string; driverData: string }>({
-  dataType: () => 'tsvector',
-});
-
-/**
- * ltree labels accept only `[A-Za-z0-9_]`, so UUID hyphens are swapped for underscores.
- * The transform is total and reversible.
- */
-export const idToLabel = (id: string): string => id.replaceAll('-', '_');
-export const labelToId = (label: string): string => {
-  const hex = label.replaceAll('_', '');
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20, 32),
-  ].join('-');
-};
-
-/** Builds the path of a node from its ancestors' ids (root first) plus its own. */
-export const buildPath = (ancestorIds: string[], selfId: string): string =>
-  [...ancestorIds, selfId].map(idToLabel).join('.');
-
-/** Splits a stored path back into ids, root first, self last. */
-export const parsePath = (path: string): string[] => path.split('.').filter(Boolean).map(labelToId);
-
-export const pathDepth = (path: string): number => (path ? path.split('.').length : 0);

package/src/errors.ts

@@ -1,50 +0,0 @@
-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,19 +0,0 @@
-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 * 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

@@ -1,21 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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,213 +0,0 @@
-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/index.js';
-
-/**
- * Both content tables share a column set, so one filter builder serves the draft and
- * the published projection. Typing the parameter as the union (rather than `PgTable`)
- * keeps real column references, which is what lets Drizzle bind arrays and UUIDs
- * correctly instead of stringifying them into the SQL text.
- */
-export type ContentTable = typeof contents | typeof publishedContents;
-
-/**
- * Note on `?: T | undefined` throughout the input types in this file: the workspace runs
- * with `exactOptionalPropertyTypes`, under which a bare `?:` accepts an absent property
- * but rejects an explicit `undefined`. Validators (Zod, and any Standard Schema) produce
- * exactly that explicit `undefined` for optional fields, so input DTOs widen while the
- * domain types they feed stay strict.
- */
-export interface FieldFilter {
-  /** Field machine name on the content type. */
-  name: string;
-  op: FilterOperator;
-  value?: unknown | undefined;
-}
-
-export interface ContentFilter {
-  spaceId?: string | undefined;
-  /** Content type ids. */
-  typeIds?: string[] | undefined;
-  locale?: string | undefined;
-  status?: 'draft' | 'published' | 'archived' | undefined;
-  ids?: string[] | undefined;
-  parentId?: string | null | undefined;
-  /** Restrict to the subtree below this content id (inclusive of its descendants). */
-  under?: string | undefined;
-  slug?: string | undefined;
-  permalink?: string | undefined;
-  localizationId?: string | undefined;
-  /** Full-text query against `title` + field contributions. */
-  search?: string | undefined;
-  fields?: FieldFilter[] | undefined;
-}
-
-export interface ContentSort {
-  by: 'position' | 'title' | 'createdAt' | 'updatedAt' | 'publishedAt' | 'slug';
-  direction: 'asc' | 'desc';
-}
-
-export interface Pagination {
-  limit: number;
-  offset: number;
-}
-
-const SORT_COLUMNS: Record<ContentSort['by'], string> = {
-  position: 'position',
-  title: 'title',
-  createdAt: 'created_at',
-  updatedAt: 'updated_at',
-  publishedAt: 'published_at',
-  slug: 'slug',
-};
-
-/**
- * Translates a filter into SQL. Every field predicate is checked against the field
- * type's declared `filters` list first: an unsupported operator is a 400, and every
- * supported one has an index behind it.
- */
-export function buildContentWhere(
-  table: ContentTable,
-  filter: ContentFilter,
-  registry: ContentTypeRegistry,
-): SQL | undefined {
-  const conditions: SQL[] = [];
-
-  if (filter.spaceId) conditions.push(eq(table.spaceId, filter.spaceId));
-  if (filter.locale) conditions.push(eq(table.locale, filter.locale));
-  if (filter.status) conditions.push(eq(table.status, filter.status));
-  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.typeIds?.length) conditions.push(inArray(table.typeId, filter.typeIds));
-  if (filter.ids?.length) conditions.push(inArray(table.id, filter.ids));
-
-  if (filter.parentId !== undefined) {
-    conditions.push(
-      filter.parentId === null ? isNull(table.parentId) : eq(table.parentId, filter.parentId),
-    );
-  }
-
-  if (filter.under) {
-    // GiST-indexed ancestor test — the whole subtree without a recursive query.
-    conditions.push(
-      sql`${table.path} <@ (select path from ${table} where id = ${filter.under}::uuid)`,
-    );
-  }
-
-  if (filter.search) {
-    conditions.push(sql`${table.search} @@ websearch_to_tsquery('simple', ${filter.search})`);
-  }
-
-  for (const fieldFilter of filter.fields ?? []) {
-    conditions.push(buildFieldCondition(table, fieldFilter, filter.typeIds ?? [], registry));
-  }
-
-  return conditions.length > 0 ? and(...conditions) : undefined;
-}
-
-function buildFieldCondition(
-  table: ContentTable,
-  filter: FieldFilter,
-  typeIds: string[],
-  registry: ContentTypeRegistry,
-): SQL {
-  assertOperatorAllowed(filter, typeIds, registry);
-
-  const path = sql`${table.fields} -> ${filter.name}`;
-  const text = sql`${table.fields} ->> ${filter.name}`;
-
-  switch (filter.op) {
-    case 'eq':
-      // jsonb containment, so the `jsonb_path_ops` GIN index can serve it.
-      return sql`${table.fields} @> jsonb_build_object(${filter.name}::text, ${JSON.stringify(filter.value ?? null)}::jsonb)`;
-    case 'neq':
-      return sql`not (${table.fields} @> jsonb_build_object(${filter.name}::text, ${JSON.stringify(filter.value ?? null)}::jsonb))`;
-    case 'in':
-      return sql`${text} = any(${sql.param(asStringArray(filter.value))}::text[])`;
-    case 'notIn':
-      return sql`${text} <> all(${sql.param(asStringArray(filter.value))}::text[])`;
-    case 'lt':
-      return sql`(${text})::numeric < ${asNumber(filter.value)}`;
-    case 'lte':
-      return sql`(${text})::numeric <= ${asNumber(filter.value)}`;
-    case 'gt':
-      return sql`(${text})::numeric > ${asNumber(filter.value)}`;
-    case 'gte':
-      return sql`(${text})::numeric >= ${asNumber(filter.value)}`;
-    case 'contains':
-      return sql`${text} ilike ${`%${escapeLike(String(filter.value ?? ''))}%`}`;
-    case 'startsWith':
-      return sql`${text} ilike ${`${escapeLike(String(filter.value ?? ''))}%`}`;
-    case 'endsWith':
-      return sql`${text} ilike ${`%${escapeLike(String(filter.value ?? ''))}`}`;
-    case 'isNull':
-      return sql`(${path} is null or ${path} = 'null'::jsonb)`;
-    case 'isNotNull':
-      return sql`(${path} is not null and ${path} <> 'null'::jsonb)`;
-    default: {
-      const exhaustive: never = filter.op;
-      throw ManabloxError.badRequest('query.operator.unsupported', { op: exhaustive });
-    }
-  }
-}
-
-/**
- * A field predicate is only accepted when *every* candidate content type declares a
- * field of that name whose field type supports the operator.
- */
-function assertOperatorAllowed(
-  filter: FieldFilter,
-  typeIds: string[],
-  registry: ContentTypeRegistry,
-): void {
-  const candidates =
-    typeIds.length > 0 ? typeIds.map((id) => registry.get(id)) : registry.contentTypes;
-
-  const matching = candidates
-    .map((type) => type.fields.find((field) => field.name === filter.name))
-    .filter((field): field is NonNullable<typeof field> => field !== undefined);
-
-  if (matching.length === 0) {
-    throw ManabloxError.badRequest('query.field.unknown', { field: filter.name });
-  }
-
-  for (const field of matching) {
-    const fieldType = registry.fieldTypes.tryGet(field.type);
-    if (!fieldType?.filters.includes(filter.op)) {
-      throw ManabloxError.badRequest('query.operator.unsupported', {
-        field: filter.name,
-        fieldType: field.type,
-        op: filter.op,
-      });
-    }
-  }
-}
-
-export function buildOrderBy(sorts: ContentSort[]): SQL {
-  if (sorts.length === 0) {
-    return sql`${sql.identifier('position')} asc, ${sql.identifier('created_at')} asc`;
-  }
-  const parts = sorts.map((sort) => {
-    const column = SORT_COLUMNS[sort.by];
-    if (!column) throw ManabloxError.badRequest('query.sort.unsupported', { by: sort.by });
-    return sql`${sql.identifier(column)} ${sql.raw(sort.direction === 'desc' ? 'desc' : 'asc')}`;
-  });
-  return parts.reduce((acc, part) => sql`${acc}, ${part}`);
-}
-
-const escapeLike = (value: string): string => value.replace(/[%_\\]/g, (c) => `\\${c}`);
-
-function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) throw ManabloxError.badRequest('query.value.expectedArray');
-  return value.map((entry) => String(entry));
-}
-
-function asNumber(value: unknown): number {
-  const parsed = Number(value);
-  if (Number.isNaN(parsed)) throw ManabloxError.badRequest('query.value.expectedNumber');
-  return parsed;
-}
-
-export type { PgColumn };