@manablox/db 0.2.0 → 0.4.0

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/schema-Dm3RcBst.js

@@ -0,0 +1,648 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { relations, sql } from "drizzle-orm";
+import { bigserial, boolean, customType, index, integer, jsonb, pgTable, primaryKey, text, timestamp, unique, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+//#region src/columns.ts
+/**
+* `ltree` — the materialised ancestor path of a content node. A subtree move is one
+* `UPDATE ... SET path = :newParent || subpath(path, nlevel(:oldParent))`.
+*/
+const ltree = customType({ dataType: () => "ltree" });
+/** `tsvector` — generated from `title` + `search_text`, never written directly. */
+const tsvector = customType({ dataType: () => "tsvector" });
+/**
+* ltree labels accept only `[A-Za-z0-9_]`, so UUID hyphens are swapped for underscores.
+* The transform is total and reversible.
+*/
+const idToLabel = (id) => id.replaceAll("-", "_");
+const labelToId = (label) => {
+	const hex = label.replaceAll("_", "");
+	return [
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		hex.slice(12, 16),
+		hex.slice(16, 20),
+		hex.slice(20, 32)
+	].join("-");
+};
+/** Builds the path of a node from its ancestors' ids (root first) plus its own. */
+const buildPath = (ancestorIds, selfId) => [...ancestorIds, selfId].map(idToLabel).join(".");
+/** Splits a stored path back into ids, root first, self last. */
+const parsePath = (path) => path.split(".").filter(Boolean).map(labelToId);
+const pathDepth = (path) => path ? path.split(".").length : 0;
+//#endregion
+//#region src/schema/spaces.ts
+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().notNull().default(sql`'["en"]'::jsonb`),
+	settings: jsonb().$type().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)]);
+//#endregion
+//#region src/schema/content.ts
+/** 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().notNull().default("draft"),
+	position: integer().notNull().default(0),
+	fields: jsonb().$type().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 })
+};
+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),
+	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.
+*/
+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. */
+const contentVersions = pgTable("content_versions", {
+	id: uuid().primaryKey().defaultRandom(),
+	contentId: uuid().notNull(),
+	version: integer().notNull(),
+	label: text(),
+	snapshot: jsonb().$type().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)]);
+//#endregion
+//#region src/schema/assets.ts
+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().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)
+]);
+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.
+*/
+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] }),
+	index("asset_usages_published_idx").on(table.assetId, table.published),
+	index("asset_usages_content_idx").on(table.contentId)
+]);
+//#endregion
+//#region src/schema/audit.ts
+/**
+* The audit log: one row per action, appended and never changed.
+*
+* Nothing here references another table. A space, a user or a document may be deleted
+* long after the row was written, and the row must still say who did what: the actor
+* and the target are recorded by id *and* by label, as they were at the time. A trigger
+* (see the migration) refuses every `update` and `delete`, and each row carries the
+* SHA-256 of its content chained to the previous row's, so a gap or an edit shows up
+* when the chain is verified.
+*/
+const auditEntries = pgTable("audit_entries", {
+	id: uuid().primaryKey().defaultRandom(),
+	/** The order of the chain; assigned by the database, gapless within a transaction. */
+	seq: bigserial({ mode: "number" }).notNull(),
+	at: timestamp({ withTimezone: true }).notNull().defaultNow(),
+	/** Null for an instance-wide action: an account, a key, creating a space. */
+	spaceId: uuid(),
+	actorKind: text().$type().notNull(),
+	actorId: text(),
+	actorLabel: text().notNull(),
+	actorDetail: jsonb().$type(),
+	action: text().$type().notNull(),
+	targetKind: text().$type().notNull(),
+	targetId: text(),
+	targetLabel: text(),
+	changes: jsonb().$type().notNull().default(sql`'[]'::jsonb`),
+	meta: jsonb().$type(),
+	prevHash: text(),
+	hash: text().notNull()
+}, (table) => [
+	index("audit_entries_seq_idx").on(table.seq),
+	index("audit_entries_space_at_idx").on(table.spaceId, table.at),
+	index("audit_entries_target_idx").on(table.targetKind, table.targetId),
+	index("audit_entries_actor_idx").on(table.actorKind, table.actorId),
+	index("audit_entries_action_idx").on(table.action)
+]);
+//#endregion
+//#region src/schema/auth.ts
+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(),
+	/**
+	* Per notification kind, the channels this person switched on or off. Only what
+	* differs from the catalogue's defaults is stored; see `resolveNotificationPreferences`.
+	*/
+	notificationPreferences: jsonb().$type().notNull().default(sql`'{}'::jsonb`),
+	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. */
+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)
+]);
+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)]);
+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)]);
+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(),
+	/**
+	* 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(),
+	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. */
+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.
+*/
+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().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)]);
+//#endregion
+//#region src/schema/content-types.ts
+/** Runtime-defined content types only; code-defined ones live in the registry. */
+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().notNull().default("content"),
+	hasSlug: boolean().notNull().default(true),
+	isPublishable: boolean().notNull().default(true),
+	isVisibleInTree: boolean().notNull().default(true),
+	canBeVisibleInMenu: boolean().notNull().default(true),
+	requiresApproval: boolean().notNull().default(false),
+	fields: jsonb().$type().notNull().default(sql`'[]'::jsonb`),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+	updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow()
+}, (table) => [unique("content_types_space_name_key").on(table.spaceId, table.name).nullsNotDistinct(), index("content_types_space_idx").on(table.spaceId)]);
+//#endregion
+//#region src/schema/menus.ts
+/**
+* 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.
+*/
+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.
+*/
+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(() => 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)]);
+//#endregion
+//#region src/schema/notifications.ts
+/**
+* One notification, for one person. A single event that concerns five people is five
+* rows, so each can be read, kept or dropped on its own; the fan-out is the service's.
+*
+* The row is the in-app copy. Email and push are sent at the same time and leave no
+* row of their own: a notification the person turned off in the admin but kept by
+* email is a mail, not a row here.
+*/
+const notifications = pgTable("notifications", {
+	id: uuid().primaryKey().defaultRandom(),
+	userId: uuid().notNull().references(() => users.id, { onDelete: "cascade" }),
+	/** Null for something that concerns the instance rather than a space. */
+	spaceId: uuid().references(() => spaces.id, { onDelete: "cascade" }),
+	kind: text().$type().notNull(),
+	title: text().notNull(),
+	body: text().notNull().default(""),
+	/** Where to go in the admin, as a path: `/content/<id>`. */
+	url: text(),
+	/** What it is about, so the inbox can group and a target's later fate can be shown. */
+	targetKind: text(),
+	targetId: text(),
+	/**
+	* Who caused it; `null` for the system. Text rather than a uuid, like the audit
+	* log's actor: it is a snapshot of whoever acted, not a reference.
+	*/
+	actorId: text(),
+	actorLabel: text(),
+	meta: jsonb().$type(),
+	readAt: timestamp({ withTimezone: true }),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow()
+}, (table) => [
+	index("notifications_user_created_idx").on(table.userId, table.createdAt),
+	index("notifications_user_unread_idx").on(table.userId, table.readAt),
+	index("notifications_target_idx").on(table.targetKind, table.targetId)
+]);
+/**
+* A request to publish a document on the author's behalf, and what became of it. One
+* document may have several over its life (sent back, resubmitted), but at most one
+* pending at a time; the service keeps that rule, the table keeps the history.
+*
+* Cascades with the document: a deleted draft has nothing left to approve.
+*/
+const contentApprovals = pgTable("content_approvals", {
+	id: uuid().primaryKey().defaultRandom(),
+	spaceId: uuid().notNull().references(() => spaces.id, { onDelete: "cascade" }),
+	contentId: uuid().notNull().references(() => contents.id, { onDelete: "cascade" }),
+	typeId: uuid().notNull(),
+	status: text().$type().notNull().default("pending"),
+	/** Who asked; kept even once the account is gone, so the history stays readable. */
+	requestedBy: uuid(),
+	requestedByLabel: text().notNull().default(""),
+	requestNote: text(),
+	/** The document's version when it was submitted, so a reviewer sees what changed since. */
+	contentVersion: integer(),
+	requestedAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+	decidedBy: uuid(),
+	decidedByLabel: text(),
+	decisionNote: text(),
+	decidedAt: timestamp({ withTimezone: true })
+}, (table) => [index("content_approvals_content_idx").on(table.contentId, table.requestedAt), index("content_approvals_space_status_idx").on(table.spaceId, table.status, table.requestedAt)]);
+//#endregion
+//#region src/schema/relations.ts
+const spacesRelations = relations(spaces, ({ many }) => ({
+	contents: many(contents),
+	contentTypes: many(contentTypes),
+	assets: many(assets),
+	memberships: many(memberships),
+	menus: many(menus),
+	roles: many(roles)
+}));
+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)
+}));
+const assetsRelations = relations(assets, ({ one, many }) => ({
+	space: one(spaces, {
+		fields: [assets.spaceId],
+		references: [spaces.id]
+	}),
+	variants: many(assetVariants)
+}));
+const assetVariantsRelations = relations(assetVariants, ({ one }) => ({ asset: one(assets, {
+	fields: [assetVariants.assetId],
+	references: [assets.id]
+}) }));
+const assetUsagesRelations = relations(assetUsages, ({ one }) => ({
+	asset: one(assets, {
+		fields: [assetUsages.assetId],
+		references: [assets.id]
+	}),
+	content: one(contents, {
+		fields: [assetUsages.contentId],
+		references: [contents.id]
+	})
+}));
+const usersRelations = relations(users, ({ many }) => ({
+	sessions: many(sessions),
+	memberships: many(memberships)
+}));
+const membershipsRelations = relations(memberships, ({ one }) => ({
+	user: one(users, {
+		fields: [memberships.userId],
+		references: [users.id]
+	}),
+	space: one(spaces, {
+		fields: [memberships.spaceId],
+		references: [spaces.id]
+	})
+}));
+const menusRelations = relations(menus, ({ one, many }) => ({
+	space: one(spaces, {
+		fields: [menus.spaceId],
+		references: [spaces.id]
+	}),
+	items: many(menuItems)
+}));
+const menuItemsRelations = relations(menuItems, ({ one }) => ({ menu: one(menus, {
+	fields: [menuItems.menuId],
+	references: [menus.id]
+}) }));
+const rolesRelations = relations(roles, ({ one }) => ({ space: one(spaces, {
+	fields: [roles.spaceId],
+	references: [spaces.id]
+}) }));
+//#endregion
+//#region src/schema/webhooks.ts
+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().notNull().default(sql`'[]'::jsonb`),
+	enabled: boolean().notNull().default(true),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow()
+}, (table) => [index("webhooks_space_idx").on(table.spaceId)]);
+const webhookDeliveries = pgTable("webhook_deliveries", {
+	id: uuid().primaryKey().defaultRandom(),
+	webhookId: uuid().notNull().references(() => webhooks.id, { onDelete: "cascade" }),
+	event: text().notNull(),
+	payload: jsonb().$type().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)]);
+//#endregion
+//#region src/schema/workflows.ts
+/**
+* A workflow: something that happens when content changes, or on a schedule. The
+* trigger and the steps are documents rather than rows — a workflow is edited and saved
+* as one thing, and a step type added later needs no migration.
+*/
+const workflows = pgTable("workflows", {
+	id: uuid().primaryKey().defaultRandom(),
+	spaceId: uuid().notNull().references(() => spaces.id, { onDelete: "cascade" }),
+	name: text().notNull(),
+	description: text(),
+	enabled: boolean().notNull().default(false),
+	trigger: jsonb().$type().notNull(),
+	steps: jsonb().$type().notNull().default(sql`'[]'::jsonb`),
+	/**
+	* The minute a scheduled workflow was last claimed for, so two processes ticking at
+	* once start one run between them rather than one each.
+	*/
+	lastScheduledAt: timestamp({ withTimezone: true }),
+	lastRunAt: timestamp({ withTimezone: true }),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+	updatedAt: timestamp({ withTimezone: true }).notNull().defaultNow()
+}, (table) => [index("workflows_space_idx").on(table.spaceId, table.enabled)]);
+/**
+* One execution of a workflow, with everything needed to continue it after a pause: the
+* context the templates read, the index of the next step and the log so far.
+*/
+const workflowRuns = pgTable("workflow_runs", {
+	id: uuid().primaryKey().defaultRandom(),
+	workflowId: uuid().notNull().references(() => workflows.id, { onDelete: "cascade" }),
+	spaceId: uuid().notNull().references(() => spaces.id, { onDelete: "cascade" }),
+	/** The event name, or `schedule` / `manual`. */
+	trigger: text().notNull(),
+	status: text().$type().notNull().default("queued"),
+	context: jsonb().$type().notNull(),
+	/** Where to continue; a paused run resumes here. See `WorkflowCursor`. */
+	cursor: jsonb().$type().notNull().default(sql`'[]'::jsonb`),
+	log: jsonb().$type().notNull().default(sql`'[]'::jsonb`),
+	error: text(),
+	/** Set while `waiting`: when the scheduler should pick the run up again. */
+	resumeAt: timestamp({ withTimezone: true }),
+	startedAt: timestamp({ withTimezone: true }),
+	finishedAt: timestamp({ withTimezone: true }),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow()
+}, (table) => [index("workflow_runs_workflow_idx").on(table.workflowId, table.createdAt), index("workflow_runs_resume_idx").on(table.status, table.resumeAt)]);
+/** A browser a user allowed push notifications in; one row per device. */
+const pushSubscriptions = pgTable("push_subscriptions", {
+	id: uuid().primaryKey().defaultRandom(),
+	userId: uuid().notNull().references(() => users.id, { onDelete: "cascade" }),
+	endpoint: text().notNull().unique("push_subscriptions_endpoint_key"),
+	keys: jsonb().$type().notNull(),
+	userAgent: text(),
+	createdAt: timestamp({ withTimezone: true }).notNull().defaultNow(),
+	lastUsedAt: timestamp({ withTimezone: true })
+}, (table) => [index("push_subscriptions_user_idx").on(table.userId)]);
+//#endregion
+//#region src/schema/index.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	accounts: () => accounts,
+	apikeys: () => apikeys,
+	assetUsages: () => assetUsages,
+	assetUsagesRelations: () => assetUsagesRelations,
+	assetVariants: () => assetVariants,
+	assetVariantsRelations: () => assetVariantsRelations,
+	assets: () => assets,
+	assetsRelations: () => assetsRelations,
+	auditEntries: () => auditEntries,
+	contentApprovals: () => contentApprovals,
+	contentTypes: () => contentTypes,
+	contentVersions: () => contentVersions,
+	contents: () => contents,
+	contentsRelations: () => contentsRelations,
+	memberships: () => memberships,
+	membershipsRelations: () => membershipsRelations,
+	menuItems: () => menuItems,
+	menuItemsRelations: () => menuItemsRelations,
+	menus: () => menus,
+	menusRelations: () => menusRelations,
+	notifications: () => notifications,
+	publishedContents: () => publishedContents,
+	pushSubscriptions: () => pushSubscriptions,
+	roles: () => roles,
+	rolesRelations: () => rolesRelations,
+	sessions: () => sessions,
+	spaces: () => spaces,
+	spacesRelations: () => spacesRelations,
+	users: () => users,
+	usersRelations: () => usersRelations,
+	verifications: () => verifications,
+	webhookDeliveries: () => webhookDeliveries,
+	webhooks: () => webhooks,
+	workflowRuns: () => workflowRuns,
+	workflows: () => workflows
+});
+//#endregion
+export { assetUsages as A, ltree as B, apikeys as C, users as D, sessions as E, publishedContents as F, pathDepth as H, spaces as I, buildPath as L, assets as M, contentVersions as N, verifications as O, contents as P, idToLabel as R, accounts as S, roles as T, tsvector as U, parsePath as V, contentApprovals as _, webhookDeliveries as a, menus as b, assetVariantsRelations as c, membershipsRelations as d, menuItemsRelations as f, usersRelations as g, spacesRelations as h, workflows as i, assetVariants as j, auditEntries as k, assetsRelations as l, rolesRelations as m, pushSubscriptions as n, webhooks as o, menusRelations as p, workflowRuns as r, assetUsagesRelations as s, schema_exports as t, contentsRelations as u, notifications as v, memberships as w, contentTypes as x, menuItems as y, labelToId as z };

package/dist/schema.d.ts

@@ -0,0 +1,2 @@
+import { $ as assetUsages, A as contentsRelations, B as menus, C as workflows, D as assetUsagesRelations, E as spaces, F as spacesRelations, G as accounts, H as contentVersions, I as usersRelations, J as roles, K as apikeys, L as contentApprovals, M as menuItemsRelations, N as menusRelations, O as assetVariantsRelations, P as rolesRelations, Q as auditEntries, R as notifications, S as workflowRuns, T as webhooks, U as contents, V as contentTypes, W as publishedContents, X as users, Y as sessions, Z as verifications, _ as UserRow, a as ContentApprovalRow, c as ContentTypeRow, d as MenuItemRow, et as assetVariants, f as MenuRow, g as SpaceRow, h as RoleRow, i as AuditEntryRow, j as membershipsRelations, k as assetsRelations, l as ContentVersionRow, m as PushSubscriptionRow, n as AssetUsageRow, o as ContentInsert, p as NotificationRow, q as memberships, r as AssetVariantRow, s as ContentRow, t as AssetRow, tt as assets, u as MembershipRow, v as WorkflowRow, w as webhookDeliveries, x as pushSubscriptions, y as WorkflowRunRow, z as menuItems } from "./index-DrNMGM9N.js";
+export { AssetRow, AssetUsageRow, AssetVariantRow, AuditEntryRow, ContentApprovalRow, ContentInsert, ContentRow, ContentTypeRow, ContentVersionRow, MembershipRow, MenuItemRow, MenuRow, NotificationRow, PushSubscriptionRow, RoleRow, SpaceRow, UserRow, WorkflowRow, WorkflowRunRow, accounts, apikeys, assetUsages, assetUsagesRelations, assetVariants, assetVariantsRelations, assets, assetsRelations, auditEntries, contentApprovals, contentTypes, contentVersions, contents, contentsRelations, memberships, membershipsRelations, menuItems, menuItemsRelations, menus, menusRelations, notifications, publishedContents, pushSubscriptions, roles, rolesRelations, sessions, spaces, spacesRelations, users, usersRelations, verifications, webhookDeliveries, webhooks, workflowRuns, workflows };

package/dist/schema.js

@@ -0,0 +1,2 @@
+import { A as assetUsages, C as apikeys, D as users, E as sessions, F as publishedContents, I as spaces, M as assets, N as contentVersions, O as verifications, P as contents, S as accounts, T as roles, _ as contentApprovals, a as webhookDeliveries, b as menus, c as assetVariantsRelations, d as membershipsRelations, f as menuItemsRelations, g as usersRelations, h as spacesRelations, i as workflows, j as assetVariants, k as auditEntries, l as assetsRelations, m as rolesRelations, n as pushSubscriptions, o as webhooks, p as menusRelations, r as workflowRuns, s as assetUsagesRelations, u as contentsRelations, v as notifications, w as memberships, x as contentTypes, y as menuItems } from "./schema-Dm3RcBst.js";
+export { accounts, apikeys, assetUsages, assetUsagesRelations, assetVariants, assetVariantsRelations, assets, assetsRelations, auditEntries, contentApprovals, contentTypes, contentVersions, contents, contentsRelations, memberships, membershipsRelations, menuItems, menuItemsRelations, menus, menusRelations, notifications, publishedContents, pushSubscriptions, roles, rolesRelations, sessions, spaces, spacesRelations, users, usersRelations, verifications, webhookDeliveries, webhooks, workflowRuns, workflows };