@manablox/db 0.2.0 → 0.3.0

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 };

package/src/repositories/asset-usage.ts

@@ -1,166 +0,0 @@
-import { and, eq, inArray, notInArray, sql } from 'drizzle-orm';
-import type { Database } from '../client.js';
-import { assetUsages, contents, publishedContents } from '../schema/index.js';
-
-/**
- * The asset → document reachability index.
- *
- * `published` tracks the *published projection*, not the draft: a draft that adds an
- * image does not make that image public, and a draft that removes one does not make it
- * private until the change is published. Every method below preserves that distinction,
- * which is why the column exists rather than the table simply holding published rows.
- */
-export class AssetUsageRepository {
-  constructor(private readonly db: Database) {}
-
-  /** The subset of `assetIds` reachable from at least one published document. */
-  async filterPublished(assetIds: string[]): Promise<Set<string>> {
-    if (assetIds.length === 0) return new Set();
-    const rows = await this.db
-      .selectDistinct({ assetId: assetUsages.assetId })
-      .from(assetUsages)
-      .where(and(inArray(assetUsages.assetId, assetIds), eq(assetUsages.published, true)));
-    return new Set(rows.map((row) => row.assetId));
-  }
-
-  async forContent(contentId: string): Promise<Array<{ assetId: string; published: boolean }>> {
-    return this.db
-      .select({ assetId: assetUsages.assetId, published: assetUsages.published })
-      .from(assetUsages)
-      .where(eq(assetUsages.contentId, contentId));
-  }
-
-  /**
-   * Records what a *draft* references.
-   *
-   * Rows the draft dropped are removed only if they are not currently published —
-   * otherwise editing a draft would silently revoke access to an image the live page is
-   * still showing.
-   */
-  async recordDraft(contentId: string, spaceId: string, assetIds: string[]): Promise<void> {
-    const unique = [...new Set(assetIds)];
-
-    await this.db.transaction(async (tx) => {
-      await tx
-        .delete(assetUsages)
-        .where(
-          and(
-            eq(assetUsages.contentId, contentId),
-            eq(assetUsages.published, false),
-            ...(unique.length > 0 ? [notInArray(assetUsages.assetId, unique)] : []),
-          ),
-        );
-
-      if (unique.length === 0) return;
-
-      await tx
-        .insert(assetUsages)
-        .values(
-          unique.map((assetId) => ({
-            assetId,
-            contentId,
-            spaceId,
-            published: false,
-            updatedAt: new Date(),
-          })),
-        )
-        // A row that is already published stays published: this write describes the
-        // draft, and `onConflictDoNothing` is the difference between recording a draft
-        // and revoking a live asset.
-        .onConflictDoNothing();
-    });
-  }
-
-  /**
-   * Records what the published projection references.
-   *
-   * Assets the new revision no longer uses lose their published flag but keep their row
-   * when the draft still references them, so the admin's "where is this used" view stays
-   * complete.
-   */
-  async recordPublished(contentId: string, spaceId: string, assetIds: string[]): Promise<void> {
-    const unique = [...new Set(assetIds)];
-
-    await this.db.transaction(async (tx) => {
-      await tx
-        .update(assetUsages)
-        .set({ published: false, updatedAt: new Date() })
-        .where(
-          and(
-            eq(assetUsages.contentId, contentId),
-            ...(unique.length > 0 ? [notInArray(assetUsages.assetId, unique)] : []),
-          ),
-        );
-
-      if (unique.length === 0) return;
-
-      await tx
-        .insert(assetUsages)
-        .values(
-          unique.map((assetId) => ({
-            assetId,
-            contentId,
-            spaceId,
-            published: true,
-            updatedAt: new Date(),
-          })),
-        )
-        .onConflictDoUpdate({
-          target: [assetUsages.assetId, assetUsages.contentId],
-          set: { published: true, updatedAt: new Date() },
-        });
-    });
-  }
-
-  /** Unpublishing revokes every asset this document was keeping public. */
-  async clearPublished(contentId: string): Promise<void> {
-    await this.db
-      .update(assetUsages)
-      .set({ published: false, updatedAt: new Date() })
-      .where(eq(assetUsages.contentId, contentId));
-  }
-
-  async deleteForContent(contentId: string): Promise<void> {
-    await this.db.delete(assetUsages).where(eq(assetUsages.contentId, contentId));
-  }
-
-  async count(): Promise<number> {
-    const rows = await this.db.select({ count: sql<number>`count(*)::int` }).from(assetUsages);
-    return rows[0]?.count ?? 0;
-  }
-
-  /**
-   * Every document with its draft and published field values, for the backfill.
-   *
-   * References are derived from field-type definitions rather than stored, so the
-   * backfill cannot be a SQL migration — it has to run inside the application.
-   */
-  async backfillSource(): Promise<
-    Array<{
-      id: string;
-      spaceId: string;
-      typeId: string;
-      draftFields: Record<string, unknown>;
-      publishedFields: Record<string, unknown> | null;
-    }>
-  > {
-    const rows = await this.db
-      .select({
-        id: contents.id,
-        spaceId: contents.spaceId,
-        typeId: contents.typeId,
-        draftFields: contents.fields,
-        publishedFields: publishedContents.fields,
-      })
-      .from(contents)
-      .leftJoin(publishedContents, eq(publishedContents.id, contents.id));
-
-    return rows.map((row) => ({
-      id: row.id,
-      spaceId: row.spaceId,
-      typeId: row.typeId,
-      draftFields: row.draftFields as Record<string, unknown>,
-      publishedFields: (row.publishedFields as Record<string, unknown> | null) ?? null,
-    }));
-  }
-}

package/src/repositories/asset.ts

@@ -1,181 +0,0 @@
-import { type Loose, ManabloxError } from '@manablox/core';
-import { and, desc, eq, inArray, sql } from 'drizzle-orm';
-import type { Database } from '../client.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;
-  spaceId: string;
-  driver: string;
-  key: string;
-  filename: string;
-  name: string;
-  mimeType: string;
-  size: number;
-  width?: number | null | undefined;
-  height?: number | null | undefined;
-  duration?: number | null | undefined;
-  checksum?: string | null | undefined;
-  alt?: string | null | undefined;
-  title?: string | null | undefined;
-  meta?: Record<string, unknown> | undefined;
-  actorId?: string | null | undefined;
-}
-
-export interface AssetFilter {
-  spaceId: string;
-  /** Prefix match on the mime type, e.g. `image/`. */
-  mimeType?: string | undefined;
-  search?: string | undefined;
-}
-
-export class AssetRepository {
-  constructor(private readonly db: Database) {}
-
-  async findById(id: string): Promise<AssetRow | null> {
-    const rows = await this.db.select().from(assets).where(eq(assets.id, id)).limit(1);
-    return rows[0] ?? null;
-  }
-
-  /**
-   * `spaceId` is not an optimisation. On the public instance an asset id is the only
-   * thing a caller supplies, and without this predicate any id resolves — including one
-   * belonging to another tenant sharing the process.
-   */
-  async findManyByIds(ids: string[], spaceId?: string | null): Promise<AssetRow[]> {
-    if (ids.length === 0) return [];
-    const where = spaceId
-      ? and(inArray(assets.id, ids), eq(assets.spaceId, spaceId))
-      : inArray(assets.id, ids);
-    return this.db.select().from(assets).where(where);
-  }
-
-  async findByChecksum(spaceId: string, checksum: string): Promise<AssetRow | null> {
-    const rows = await this.db
-      .select()
-      .from(assets)
-      .where(and(eq(assets.spaceId, spaceId), eq(assets.checksum, checksum)))
-      .limit(1);
-    return rows[0] ?? null;
-  }
-
-  async list(filter: AssetFilter, pagination: Pagination): Promise<Paginated<AssetRow>> {
-    const conditions = [eq(assets.spaceId, filter.spaceId)];
-    if (filter.mimeType) conditions.push(sql`${assets.mimeType} like ${`${filter.mimeType}%`}`);
-    if (filter.search) {
-      conditions.push(
-        sql`(${assets.name} ilike ${`%${filter.search}%`} or ${assets.filename} ilike ${`%${filter.search}%`})`,
-      );
-    }
-
-    return paginate(this.db, assets, {
-      where: and(...conditions),
-      orderBy: desc(assets.createdAt),
-      pagination,
-    });
-  }
-
-  async create(data: AssetWriteData): Promise<AssetRow> {
-    const [row] = await this.db
-      .insert(assets)
-      .values({
-        ...(data.id ? { id: data.id } : {}),
-        spaceId: data.spaceId,
-        driver: data.driver,
-        key: data.key,
-        filename: data.filename,
-        name: data.name,
-        mimeType: data.mimeType,
-        size: data.size,
-        width: data.width ?? null,
-        height: data.height ?? null,
-        duration: data.duration ?? null,
-        checksum: data.checksum ?? null,
-        alt: data.alt ?? null,
-        title: data.title ?? null,
-        meta: data.meta ?? {},
-        createdBy: data.actorId ?? null,
-      })
-      .returning();
-    if (!row) throw new ManabloxError('asset.create.failed');
-    return row;
-  }
-
-  async update(
-    id: string,
-    data: Loose<Pick<AssetWriteData, 'name' | 'alt' | 'title' | 'meta'>>,
-  ): Promise<AssetRow> {
-    const [row] = await this.db
-      .update(assets)
-      .set({ ...data, updatedAt: new Date() })
-      .where(eq(assets.id, id))
-      .returning();
-    if (!row) throw ManabloxError.notFound('asset.notFound', { id });
-    return row;
-  }
-
-  async delete(id: string): Promise<AssetRow | null> {
-    const [row] = await this.db.delete(assets).where(eq(assets.id, id)).returning();
-    return row ?? null;
-  }
-
-  async variants(assetIds: string[]): Promise<AssetVariantRow[]> {
-    if (assetIds.length === 0) return [];
-    return this.db.select().from(assetVariants).where(inArray(assetVariants.assetId, assetIds));
-  }
-
-  async findVariant(
-    assetId: string,
-    preset: string,
-    format: string,
-  ): Promise<AssetVariantRow | null> {
-    const rows = await this.db
-      .select()
-      .from(assetVariants)
-      .where(
-        and(
-          eq(assetVariants.assetId, assetId),
-          eq(assetVariants.preset, preset),
-          eq(assetVariants.format, format),
-        ),
-      )
-      .limit(1);
-    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;
-    format: string;
-    key: string;
-    width?: number | null;
-    height?: number | null;
-    size: number;
-  }): Promise<AssetVariantRow> {
-    const [row] = await this.db
-      .insert(assetVariants)
-      .values({
-        assetId: data.assetId,
-        preset: data.preset,
-        format: data.format,
-        key: data.key,
-        width: data.width ?? null,
-        height: data.height ?? null,
-        size: data.size,
-      })
-      .onConflictDoUpdate({
-        target: [assetVariants.assetId, assetVariants.preset, assetVariants.format],
-        set: { key: data.key, size: data.size },
-      })
-      .returning();
-    if (!row) throw new ManabloxError('assetVariant.create.failed');
-    return row;
-  }
-}

package/src/repositories/content-type.ts

@@ -1,116 +0,0 @@
-import {
-  type ContentTypeDefinition,
-  type ContentTypeInput,
-  defineContentType,
-  ManabloxError,
-} from '@manablox/core';
-import { eq } from 'drizzle-orm';
-import type { Database } from '../client.js';
-import { type ContentTypeRow, contentTypes } from '../schema/index.js';
-
-/**
- * Persistence for *runtime-defined* content types only. Code-defined types come from
- * `manablox.config.ts` and are never written here — the registry merges both into one
- * shape, and `source` tells the admin which are read-only.
- */
-export class ContentTypeRepository {
-  constructor(private readonly db: Database) {}
-
-  async all(): Promise<ContentTypeDefinition[]> {
-    const rows = await this.db.select().from(contentTypes);
-    return rows.map(toDefinition);
-  }
-
-  async findById(id: string): Promise<ContentTypeDefinition | null> {
-    const rows = await this.db.select().from(contentTypes).where(eq(contentTypes.id, id)).limit(1);
-    return rows[0] ? toDefinition(rows[0]) : null;
-  }
-
-  async create(input: ContentTypeInput): Promise<ContentTypeDefinition> {
-    // Normalise through the same helper the config path uses, so a runtime type and a
-    // code type are byte-for-byte the same shape.
-    const definition = defineContentType(input);
-
-    const [row] = await this.db
-      .insert(contentTypes)
-      .values({
-        id: definition.id,
-        spaceId: definition.spaceId,
-        name: definition.name,
-        label: definition.label,
-        description: definition.description ?? null,
-        icon: definition.icon ?? null,
-        kind: definition.kind,
-        hasSlug: definition.hasSlug,
-        isPublishable: definition.isPublishable,
-        isVisibleInTree: definition.isVisibleInTree,
-        canBeVisibleInMenu: definition.canBeVisibleInMenu,
-        fields: definition.fields,
-      })
-      .returning();
-
-    if (!row) throw new ManabloxError('contentType.create.failed');
-    return toDefinition(row);
-  }
-
-  async update(id: string, input: ContentTypeInput): Promise<ContentTypeDefinition> {
-    const existing = await this.findById(id);
-    if (!existing) throw ManabloxError.notFound('contentType.notFound', { id });
-
-    const definition = defineContentType({ ...input, id });
-
-    // Field machine names are part of the public GraphQL schema. Renaming one would
-    // silently break every consumer query, so a rename is expressed as remove + add.
-    for (const field of definition.fields) {
-      const previous = existing.fields.find((candidate) => candidate.id === field.id);
-      if (previous && previous.name !== field.name) {
-        throw ManabloxError.badRequest('contentType.field.name.immutable', {
-          from: previous.name,
-          to: field.name,
-        });
-      }
-    }
-
-    const [row] = await this.db
-      .update(contentTypes)
-      .set({
-        name: definition.name,
-        label: definition.label,
-        description: definition.description ?? null,
-        icon: definition.icon ?? null,
-        hasSlug: definition.hasSlug,
-        isPublishable: definition.isPublishable,
-        isVisibleInTree: definition.isVisibleInTree,
-        canBeVisibleInMenu: definition.canBeVisibleInMenu,
-        fields: definition.fields,
-        updatedAt: new Date(),
-      })
-      .where(eq(contentTypes.id, id))
-      .returning();
-
-    if (!row) throw ManabloxError.notFound('contentType.notFound', { id });
-    return toDefinition(row);
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.db.delete(contentTypes).where(eq(contentTypes.id, id));
-  }
-}
-
-function toDefinition(row: ContentTypeRow): ContentTypeDefinition {
-  return {
-    id: row.id,
-    name: row.name,
-    label: row.label,
-    ...(row.description !== null ? { description: row.description } : {}),
-    ...(row.icon !== null ? { icon: row.icon } : {}),
-    kind: row.kind,
-    spaceId: row.spaceId,
-    hasSlug: row.hasSlug,
-    isPublishable: row.isPublishable,
-    isVisibleInTree: row.isVisibleInTree,
-    canBeVisibleInMenu: row.canBeVisibleInMenu,
-    fields: row.fields,
-    source: 'runtime',
-  };
-}