@manablox/db 0.1.0

package/src/repositories/asset.ts

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

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