@manablox/db 0.2.0 → 0.4.0

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