@manablox/db 0.2.0 → 0.4.0

package/src/schema/assets.ts

@@ -1,108 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-  boolean,
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  primaryKey,
-  text,
-  timestamp,
-  uniqueIndex,
-  uuid,
-} from 'drizzle-orm/pg-core';
-import { contents } from './content.js';
-import { spaces } from './spaces.js';
-
-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),
-  ],
-);

package/src/schema/auth.ts

@@ -1,166 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-  boolean,
-  index,
-  jsonb,
-  pgTable,
-  primaryKey,
-  text,
-  timestamp,
-  uniqueIndex,
-  uuid,
-} from 'drizzle-orm/pg-core';
-import { spaces } from './spaces.js';
-
-// better-auth owns the user, session, account and verification tables; they are 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 }),
-    /**
-     * Grants this key is confined to, in the roles' vocabulary; `null` means whatever
-     * the owner's role allows. Like `spaceIds`, a restriction only ever narrows.
-     */
-    permissions: jsonb().$type<string[] | null>(),
-    /**
-     * 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' }),
-    /** The machine name of a built-in role or of a row in `roles` for the same space. */
-    role: text().notNull().default('editor'),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.userId, table.spaceId] }),
-    index('memberships_space_idx').on(table.spaceId),
-  ],
-);
-
-/**
- * A role someone created for a space, beside the built-in five. `permissions` holds the
- * grants: `space:write`, `content:read` for every type, or `content:read:<typeId>` for
- * one. Memberships name it by `machineName`, so a custom role is one row and one name.
- */
-export const roles = pgTable(
-  'roles',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    name: text().notNull(),
-    machineName: text().notNull(),
-    description: text(),
-    permissions: jsonb().$type<string[]>().notNull().default(sql`'[]'::jsonb`),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [uniqueIndex('roles_space_machine_name_key').on(table.spaceId, table.machineName)],
-);

package/src/schema/content-types.ts

@@ -1,31 +0,0 @@
-import type { FieldDefinition } from '@manablox/core';
-import { sql } from 'drizzle-orm';
-import { boolean, index, jsonb, pgTable, text, timestamp, unique, uuid } from 'drizzle-orm/pg-core';
-import { spaces } from './spaces.js';
-
-/** Runtime-defined content types only; code-defined ones 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),
-  ],
-);

package/src/schema/content.ts

@@ -1,133 +0,0 @@
-import type { ContentStatus } from '@manablox/core';
-import { sql } from 'drizzle-orm';
-import {
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  text,
-  timestamp,
-  unique,
-  uniqueIndex,
-  uuid,
-} from 'drizzle-orm/pg-core';
-import { ltree, tsvector } from '../columns.js';
-import { spaces } from './spaces.js';
-
-/** 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'),
-  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),
-  ],
-);

package/src/schema/index.ts

@@ -1,38 +0,0 @@
-/**
- * The database schema, one file per entity. `drizzle.config.ts` points at this directory,
- * and `relations.ts` ties the tables together so `db.query` can traverse them.
- */
-export * from './assets.js';
-export * from './auth.js';
-export * from './content.js';
-export * from './content-types.js';
-export * from './menus.js';
-export * from './relations.js';
-export * from './spaces.js';
-export * from './webhooks.js';
-export * from './workflows.js';
-
-import type { assets, assetUsages, assetVariants } from './assets.js';
-import type { memberships, roles, users } from './auth.js';
-import type { contents, contentVersions } from './content.js';
-import type { contentTypes } from './content-types.js';
-import type { menuItems, menus } from './menus.js';
-import type { spaces } from './spaces.js';
-import type { pushSubscriptions, workflowRuns, workflows } from './workflows.js';
-
-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 RoleRow = typeof roles.$inferSelect;
-export type ContentVersionRow = typeof contentVersions.$inferSelect;
-export type MenuRow = typeof menus.$inferSelect;
-export type MenuItemRow = typeof menuItems.$inferSelect;
-export type WorkflowRow = typeof workflows.$inferSelect;
-export type WorkflowRunRow = typeof workflowRuns.$inferSelect;
-export type PushSubscriptionRow = typeof pushSubscriptions.$inferSelect;

package/src/schema/menus.ts

@@ -1,61 +0,0 @@
-import {
-  type AnyPgColumn,
-  index,
-  integer,
-  pgTable,
-  text,
-  timestamp,
-  unique,
-  uuid,
-} from 'drizzle-orm/pg-core';
-import { spaces } from './spaces.js';
-
-/**
- * A named navigation a site renders: "main", "footer", "legal". A document may sit in
- * any number of them, which is why membership is a row here and not a flag on the
- * document.
- */
-export const menus = pgTable(
-  'menus',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    spaceId: uuid()
-      .notNull()
-      .references(() => spaces.id, { onDelete: 'cascade' }),
-    name: text().notNull(),
-    /** What the delivery API is asked for: `menu(name: "main")`. */
-    machineName: text().notNull(),
-    description: text(),
-    createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => [unique('menus_space_machine_name_key').on(table.spaceId, table.machineName)],
-);
-
-/**
- * One entry of a menu, nested to any depth.
- *
- * A content entry points at the document's `localizationId` rather than at one row, so
- * the same menu serves every locale: delivery resolves the translation for the locale
- * it is asked for. A link entry has a `url` instead. Either may carry a `label`; for a
- * content entry it overrides the document's title.
- */
-export const menuItems = pgTable(
-  'menu_items',
-  {
-    id: uuid().primaryKey().defaultRandom(),
-    menuId: uuid()
-      .notNull()
-      .references(() => menus.id, { onDelete: 'cascade' }),
-    /** Cascades, so removing an entry takes its sub-entries with it. */
-    parentId: uuid().references((): AnyPgColumn => menuItems.id, { onDelete: 'cascade' }),
-    position: integer().notNull().default(0),
-    localizationId: uuid(),
-    label: text(),
-    url: text(),
-  },
-  (table) => [
-    index('menu_items_menu_idx').on(table.menuId, table.parentId, table.position),
-    index('menu_items_localization_idx').on(table.localizationId),
-  ],
-);

package/src/schema/relations.ts

@@ -1,64 +0,0 @@
-import { relations } from 'drizzle-orm';
-import { assets, assetUsages, assetVariants } from './assets.js';
-import { memberships, roles, sessions, users } from './auth.js';
-import { contents, contentVersions } from './content.js';
-import { contentTypes } from './content-types.js';
-import { menuItems, menus } from './menus.js';
-import { spaces } from './spaces.js';
-
-export const spacesRelations = relations(spaces, ({ many }) => ({
-  contents: many(contents),
-  contentTypes: many(contentTypes),
-  assets: many(assets),
-  memberships: many(memberships),
-  menus: many(menus),
-  roles: many(roles),
-}));
-
-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 const menusRelations = relations(menus, ({ one, many }) => ({
-  space: one(spaces, { fields: [menus.spaceId], references: [spaces.id] }),
-  items: many(menuItems),
-}));
-
-export const menuItemsRelations = relations(menuItems, ({ one }) => ({
-  menu: one(menus, { fields: [menuItems.menuId], references: [menus.id] }),
-}));
-
-export const rolesRelations = relations(roles, ({ one }) => ({
-  space: one(spaces, { fields: [roles.spaceId], references: [spaces.id] }),
-}));

package/src/schema/spaces.ts

@@ -1,20 +0,0 @@
-import { sql } from 'drizzle-orm';
-import { jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
-
-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)],
-);

package/src/schema/webhooks.ts

@@ -1,46 +0,0 @@
-import { sql } from 'drizzle-orm';
-import {
-  boolean,
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  text,
-  timestamp,
-  uuid,
-} from 'drizzle-orm/pg-core';
-import { spaces } from './spaces.js';
-
-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)],
-);