@manablox/db 0.1.0 → 0.2.0

package/src/schema.ts

@@ -1,513 +0,0 @@
-import type { ContentStatus, FieldDefinition } from '@manablox/core';
-import { relations, sql } from 'drizzle-orm';
-import {
-  boolean,
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  primaryKey,
-  text,
-  timestamp,
-  unique,
-  uniqueIndex,
-  uuid,
-} from 'drizzle-orm/pg-core';
-import { ltree, tsvector } from './columns.js';
-
-// ---------------------------------------------------------------------------
-// Spaces
-// ---------------------------------------------------------------------------
-
-export const spaces = pgTable(
-  'spaces',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    name: text().notNull(),
-    machineName: text().notNull(),
-    description: text(),
-    /** Public origin of the space's frontend — used by the visual editor iframe. */
-    url: text().notNull(),
-    defaultLocale: text().notNull().default('en'),
-    locales: jsonb().$type<string[]>().notNull().default(sql`'["en"]'::jsonb`),
-    settings: jsonb().$type<Record<string, unknown>>().notNull().default(sql`'{}'::jsonb`),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [uniqueIndex('spaces_machine_name_key').on(table.machineName)],
-);
-
-// ---------------------------------------------------------------------------
-// Content types (runtime-defined only; code-defined live in the registry)
-// ---------------------------------------------------------------------------
-
-export const contentTypes = pgTable(
-  'content_types',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    spaceId: uuid().references(() => spaces.id, { onDelete: 'cascade' }),
-    name: text().notNull(),
-    label: text().notNull(),
-    description: text(),
-    icon: text(),
-    kind: text().$type<'content' | 'block'>().notNull().default('content'),
-    hasSlug: boolean().notNull().default(true),
-    isPublishable: boolean().notNull().default(true),
-    isVisibleInTree: boolean().notNull().default(true),
-    canBeVisibleInMenu: boolean().notNull().default(true),
-    fields: jsonb().$type<FieldDefinition[]>().notNull().default(sql`'[]'::jsonb`),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    // NULLS NOT DISTINCT so two global types cannot share a name — plain UNIQUE would
-    // treat every NULL space_id as distinct and let duplicates through.
-    unique('content_types_space_name_key').on(table.spaceId, table.name).nullsNotDistinct(),
-    index('content_types_space_idx').on(table.spaceId),
-  ],
-);
-
-// ---------------------------------------------------------------------------
-// Content
-// ---------------------------------------------------------------------------
-
-/** Shared column set for `contents` and its published projection. */
-const contentColumns = {
-  id: uuid().primaryKey().defaultRandom(),
-  spaceId: uuid()
-    .notNull()
-    .references(() => spaces.id, { onDelete: 'cascade' }),
-  typeId: uuid().notNull(),
-  locale: text().notNull(),
-  /** Shared by all translations of one logical document. */
-  localizationId: uuid().notNull(),
-  parentId: uuid(),
-  title: text().notNull(),
-  slug: text().notNull(),
-  /** Materialised ancestor path, root first, ending in this node's own id. */
-  path: ltree().notNull(),
-  /** Routable URL path. NULL when the content type has no slug — such a node is a
-   * structural container, not a page, so it must not occupy a permalink of its own. */
-  permalink: text(),
-  /**
-   * Accumulated permalink prefix: every ancestor segment plus this node's own, with
-   * slug-less levels skipped. Descendants derive from this rather than from `permalink`,
-   * which is NULL for a slug-less node and would otherwise truncate the chain.
-   */
-  permalinkPath: text().notNull().default(''),
-  /**
-   * This node's own contribution to its descendants' permalinks: the slug when the
-   * content type has one, NULL when it does not.
-   *
-   * Denormalised deliberately, so permalink recomputation is a single recursive CTE that
-   * needs no knowledge of the type registry.
-   */
-  permalinkSegment: text(),
-  status: text().$type<ContentStatus>().notNull().default('draft'),
-  visibleInMenu: boolean().notNull().default(false),
-  position: integer().notNull().default(0),
-  fields: jsonb().$type<Record<string, unknown>>().notNull().default(sql`'{}'::jsonb`),
-  /** Concatenated contributions from each field type's `search()`. */
-  searchText: text().notNull().default(''),
-  /** Optimistic-lock counter; a write with a stale version is rejected. */
-  version: integer().notNull().default(1),
-  createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  createdBy: uuid(),
-  updatedBy: uuid(),
-  publishedAt: timestamp({ withTimezone: true }),
-};
-
-export const contents = pgTable(
-  'contents',
-  {
-    ...contentColumns,
-    search: tsvector().generatedAlwaysAs(
-      sql`to_tsvector('simple', coalesce(title, '') || ' ' || coalesce(search_text, ''))`,
-    ),
-  },
-  (table) => [
-    index('contents_path_gist_idx').using('gist', table.path),
-    index('contents_parent_idx').on(table.parentId),
-    index('contents_space_type_idx').on(table.spaceId, table.typeId),
-    index('contents_localization_idx').on(table.localizationId),
-    index('contents_status_idx').on(table.spaceId, table.status),
-    index('contents_fields_gin_idx').using('gin', sql`${table.fields} jsonb_path_ops`),
-    index('contents_search_gin_idx').using('gin', table.search),
-    // NULLS NOT DISTINCT so two root-level siblings cannot share a slug — with the
-    // default NULLS DISTINCT, every `parent_id IS NULL` row is unique by definition and
-    // the constraint would never fire at the top of the tree.
-    unique('contents_sibling_slug_key')
-      .on(table.spaceId, table.parentId, table.locale, table.slug)
-      .nullsNotDistinct(),
-    uniqueIndex('contents_permalink_key')
-      .on(table.spaceId, table.locale, table.permalink)
-      .where(sql`permalink is not null`),
-  ],
-);
-
-/**
- * The delivery projection. Written transactionally on publish, read by the public
- * GraphQL API. Mirrors `contents` so a row can be copied column-for-column.
- */
-export const publishedContents = pgTable(
-  'published_contents',
-  {
-    ...contentColumns,
-    /** Version of `contents` this projection was made from. */
-    sourceVersion: integer().notNull().default(1),
-    search: tsvector().generatedAlwaysAs(
-      sql`to_tsvector('simple', coalesce(title, '') || ' ' || coalesce(search_text, ''))`,
-    ),
-  },
-  (table) => [
-    index('published_contents_path_gist_idx').using('gist', table.path),
-    index('published_contents_parent_idx').on(table.parentId),
-    index('published_contents_space_type_idx').on(table.spaceId, table.typeId),
-    index('published_contents_fields_gin_idx').using('gin', sql`${table.fields} jsonb_path_ops`),
-    index('published_contents_search_gin_idx').using('gin', table.search),
-    uniqueIndex('published_contents_permalink_key')
-      .on(table.spaceId, table.locale, table.permalink)
-      .where(sql`permalink is not null`),
-  ],
-);
-
-/** Full snapshot per save, so any edit can be rolled back. */
-export const contentVersions = pgTable(
-  'content_versions',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    contentId: uuid().notNull(),
-    version: integer().notNull(),
-    label: text(),
-    snapshot: jsonb().$type<Record<string, unknown>>().notNull(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    createdBy: uuid(),
-  },
-  (table) => [
-    uniqueIndex('content_versions_content_version_key').on(table.contentId, table.version),
-    index('content_versions_content_idx').on(table.contentId, table.createdAt),
-  ],
-);
-
-// ---------------------------------------------------------------------------
-// Assets
-// ---------------------------------------------------------------------------
-
-export const assets = pgTable(
-  'assets',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    driver: text().notNull().default('local'),
-    /** Storage-relative key, e.g. `<space>/2026/09/photo.jpg`. */
-    key: text().notNull(),
-    filename: text().notNull(),
-    name: text().notNull(),
-    mimeType: text().notNull(),
-    size: integer().notNull(),
-    width: integer(),
-    height: integer(),
-    /** Seconds, for audio/video. */
-    duration: integer(),
-    /** SHA-256 of the bytes, for dedupe. */
-    checksum: text(),
-    alt: text(),
-    title: text(),
-    meta: jsonb().$type<Record<string, unknown>>().notNull().default(sql`'{}'::jsonb`),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    createdBy: uuid(),
-  },
-  (table) => [
-    uniqueIndex('assets_driver_key_key').on(table.driver, table.key),
-    index('assets_space_idx').on(table.spaceId, table.createdAt),
-    index('assets_checksum_idx').on(table.spaceId, table.checksum),
-    index('assets_mime_idx').on(table.spaceId, table.mimeType),
-  ],
-);
-
-export const assetVariants = pgTable(
-  'asset_variants',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    assetId: uuid()
-      .notNull()
-      .references(() => assets.id, { onDelete: 'cascade' }),
-    preset: text().notNull(),
-    format: text().notNull(),
-    key: text().notNull(),
-    width: integer(),
-    height: integer(),
-    size: integer().notNull(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    uniqueIndex('asset_variants_asset_preset_format_key').on(
-      table.assetId,
-      table.preset,
-      table.format,
-    ),
-  ],
-);
-
-/**
- * Which documents reference which assets, and whether any of them is published.
- *
- * Assets have no draft/published distinction of their own, so before this table an
- * asset id resolved on the public API whether or not anything published pointed at it —
- * including a file uploaded for a draft that never shipped. Maintained from the same
- * publish/unpublish/delete hooks that purge the cache, out of the references each field
- * type already declares.
- */
-export const assetUsages = pgTable(
-  'asset_usages',
-  {
-    assetId: uuid()
-      .notNull()
-      .references(() => assets.id, { onDelete: 'cascade' }),
-    contentId: uuid()
-      .notNull()
-      .references(() => contents.id, { onDelete: 'cascade' }),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    /** True when the *published* projection of `contentId` references the asset. */
-    published: boolean().notNull().default(false),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.assetId, table.contentId] }),
-    // The public asset check is `asset_id = any($1) and published`; this index serves it
-    // without touching the heap.
-    index('asset_usages_published_idx').on(table.assetId, table.published),
-    index('asset_usages_content_idx').on(table.contentId),
-  ],
-);
-
-// ---------------------------------------------------------------------------
-// Auth (better-auth owns these; declared here so Drizzle can join and migrate them)
-// ---------------------------------------------------------------------------
-
-export const users = pgTable(
-  'users',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    name: text().notNull().default(''),
-    email: text().notNull(),
-    emailVerified: boolean().notNull().default(false),
-    image: text(),
-    /** Instance-wide role. Space-scoped roles live on `memberships`. */
-    role: text().notNull().default('editor'),
-    banned: boolean().notNull().default(false),
-    banReason: text(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [uniqueIndex('users_email_key').on(table.email)],
-);
-
-/** One row per active session, so multiple devices can be signed in at once. */
-export const sessions = pgTable(
-  'sessions',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    userId: uuid()
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    token: text().notNull(),
-    expiresAt: timestamp({ withTimezone: true }).notNull(),
-    ipAddress: text(),
-    userAgent: text(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    uniqueIndex('sessions_token_key').on(table.token),
-    index('sessions_user_idx').on(table.userId),
-    index('sessions_expires_idx').on(table.expiresAt),
-  ],
-);
-
-export const accounts = pgTable(
-  'accounts',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    userId: uuid()
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    accountId: text().notNull(),
-    providerId: text().notNull(),
-    /** Required by better-auth 1.7 for OIDC issuer disambiguation. */
-    issuer: text().notNull().default(''),
-    accessToken: text(),
-    refreshToken: text(),
-    accessTokenExpiresAt: timestamp({ withTimezone: true }),
-    refreshTokenExpiresAt: timestamp({ withTimezone: true }),
-    scope: text(),
-    idToken: text(),
-    password: text(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [uniqueIndex('accounts_provider_account_key').on(table.providerId, table.accountId)],
-);
-
-export const verifications = pgTable(
-  'verifications',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    identifier: text().notNull(),
-    value: text().notNull(),
-    expiresAt: timestamp({ withTimezone: true }).notNull(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [index('verifications_identifier_idx').on(table.identifier)],
-);
-
-export const apikeys = pgTable(
-  'apikeys',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    name: text(),
-    start: text(),
-    prefix: text(),
-    key: text().notNull(),
-    userId: uuid()
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    enabled: boolean().notNull().default(true),
-    expiresAt: timestamp({ withTimezone: true }),
-    lastRequest: timestamp({ withTimezone: true }),
-    permissions: text(),
-    /**
-     * Space ids this key may act in; `null` means every space the owner belongs to.
-     * A restriction only ever narrows the owner's own access, never widens it.
-     */
-    spaceIds: jsonb().$type<string[] | null>(),
-    metadata: text(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [index('apikeys_user_idx').on(table.userId)],
-);
-
-/** Space-scoped role assignment. */
-export const memberships = pgTable(
-  'memberships',
-  {
-    userId: uuid()
-      .notNull()
-      .references(() => users.id, { onDelete: 'cascade' }),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    role: text()
-      .$type<'owner' | 'admin' | 'editor' | 'author' | 'viewer'>()
-      .notNull()
-      .default('editor'),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.userId, table.spaceId] }),
-    index('memberships_space_idx').on(table.spaceId),
-  ],
-);
-
-// ---------------------------------------------------------------------------
-// Webhooks
-// ---------------------------------------------------------------------------
-
-export const webhooks = pgTable(
-  'webhooks',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    name: text().notNull(),
-    url: text().notNull(),
-    secret: text(),
-    events: jsonb().$type<string[]>().notNull().default(sql`'[]'::jsonb`),
-    enabled: boolean().notNull().default(true),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [index('webhooks_space_idx').on(table.spaceId)],
-);
-
-export const webhookDeliveries = pgTable(
-  'webhook_deliveries',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    webhookId: uuid()
-      .notNull()
-      .references(() => webhooks.id, { onDelete: 'cascade' }),
-    event: text().notNull(),
-    payload: jsonb().$type<Record<string, unknown>>().notNull(),
-    status: integer(),
-    error: text(),
-    attempt: integer().notNull().default(1),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [index('webhook_deliveries_webhook_idx').on(table.webhookId, table.createdAt)],
-);
-
-// ---------------------------------------------------------------------------
-// Relations
-// ---------------------------------------------------------------------------
-
-export const spacesRelations = relations(spaces, ({ many }) => ({
-  contents: many(contents),
-  contentTypes: many(contentTypes),
-  assets: many(assets),
-  memberships: many(memberships),
-}));
-
-export const contentsRelations = relations(contents, ({ one, many }) => ({
-  space: one(spaces, { fields: [contents.spaceId], references: [spaces.id] }),
-  parent: one(contents, {
-    fields: [contents.parentId],
-    references: [contents.id],
-    relationName: 'tree',
-  }),
-  children: many(contents, { relationName: 'tree' }),
-  versions: many(contentVersions),
-}));
-
-export const assetsRelations = relations(assets, ({ one, many }) => ({
-  space: one(spaces, { fields: [assets.spaceId], references: [spaces.id] }),
-  variants: many(assetVariants),
-}));
-
-export const assetVariantsRelations = relations(assetVariants, ({ one }) => ({
-  asset: one(assets, { fields: [assetVariants.assetId], references: [assets.id] }),
-}));
-
-export const assetUsagesRelations = relations(assetUsages, ({ one }) => ({
-  asset: one(assets, { fields: [assetUsages.assetId], references: [assets.id] }),
-  content: one(contents, { fields: [assetUsages.contentId], references: [contents.id] }),
-}));
-
-export const usersRelations = relations(users, ({ many }) => ({
-  sessions: many(sessions),
-  memberships: many(memberships),
-}));
-
-export const membershipsRelations = relations(memberships, ({ one }) => ({
-  user: one(users, { fields: [memberships.userId], references: [users.id] }),
-  space: one(spaces, { fields: [memberships.spaceId], references: [spaces.id] }),
-}));
-
-export type SpaceRow = typeof spaces.$inferSelect;
-export type ContentRow = typeof contents.$inferSelect;
-export type ContentInsert = typeof contents.$inferInsert;
-export type ContentTypeRow = typeof contentTypes.$inferSelect;
-export type AssetRow = typeof assets.$inferSelect;
-export type AssetVariantRow = typeof assetVariants.$inferSelect;
-export type AssetUsageRow = typeof assetUsages.$inferSelect;
-export type UserRow = typeof users.$inferSelect;
-export type MembershipRow = typeof memberships.$inferSelect;
-export type ContentVersionRow = typeof contentVersions.$inferSelect;