@manablox/db 0.1.0 → 0.3.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-Bb4p16Yz.js

@@ -0,0 +1,539 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { relations, sql } from "drizzle-orm";
+import { 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/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(),
+	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),
+	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/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,
+	contentTypes: () => contentTypes,
+	contentVersions: () => contentVersions,
+	contents: () => contents,
+	contentsRelations: () => contentsRelations,
+	memberships: () => memberships,
+	membershipsRelations: () => membershipsRelations,
+	menuItems: () => menuItems,
+	menuItemsRelations: () => menuItemsRelations,
+	menus: () => menus,
+	menusRelations: () => menusRelations,
+	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 { contentVersions as A, tsvector as B, roles as C, assetUsages as D, verifications as E, idToLabel as F, labelToId as I, ltree as L, publishedContents as M, spaces as N, assetVariants as O, buildPath as P, parsePath as R, memberships as S, users as T, menuItems as _, webhookDeliveries as a, accounts as b, assetVariantsRelations as c, membershipsRelations as d, menuItemsRelations as f, usersRelations as g, spacesRelations as h, workflows as i, contents as j, assets 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, menus as v, sessions as w, apikeys as x, contentTypes as y, pathDepth as z };

package/dist/schema.d.ts

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

package/dist/testing.d.ts

@@ -0,0 +1,77 @@
+import { U as DatabaseHandle, t as Repositories } from "./index-Cyf_N5K3.js";
+import { ContentTypeDefinition, ContentTypeRegistry } from "@manablox/core";
+//#region src/testing-fixtures.d.ts
+export declare const stringField: import("@manablox/core").FieldTypeDefinition<Record<string, unknown>, string>;
+export declare const numberField: import("@manablox/core").FieldTypeDefinition<Record<string, unknown>, number>;
+export interface RepositoryTestContext {
+  handle: DatabaseHandle;
+  /** Every statement sent to Postgres, so a test can assert what a call cost. */
+  queries: string[];
+  repos: Repositories;
+  registry: ContentTypeRegistry;
+  types: {
+    page: ContentTypeDefinition;
+    folder: ContentTypeDefinition;
+  };
+  spaceId: string;
+  close: () => Promise<void>;
+}
+/** Spins up an isolated database per suite, migrated from the real migration files. */
+export declare function createRepositoryContext(name: string): Promise<RepositoryTestContext>;
+/** Convenience creator so tests read as tree shapes rather than field soup. */
+export declare function makeNode(ctx: RepositoryTestContext, options: {
+  title: string;
+  slug: string;
+  parentId?: string | null;
+  type?: 'page' | 'folder';
+  fields?: Record<string, unknown>;
+}): Promise<{
+  createdAt: Date;
+  createdBy: string | null;
+  fields: Record<string, unknown>;
+  id: string;
+  locale: string;
+  localizationId: string;
+  parentId: string | null;
+  path: string;
+  permalink: string | null;
+  permalinkPath: string;
+  permalinkSegment: string | null;
+  position: number;
+  publishedAt: Date | null;
+  search: string | null;
+  searchText: string;
+  slug: string;
+  spaceId: string;
+  status: import("@manablox/core").ContentStatus;
+  title: string;
+  typeId: string;
+  updatedAt: Date;
+  updatedBy: string | null;
+  version: number;
+}>;
+//#endregion
+//#region src/testing.d.ts
+/**
+ * Only ever connected to in order to `create database`: every test file works in its own
+ * fresh database and drops it again, so this points at a Postgres *server*, not at data
+ * the tests touch. That is why falling back to `DATABASE_URL` is safe — it means the
+ * suite runs wherever the app itself runs (a container, CI, the host) without a second
+ * variable that has to be kept in step. `TEST_DATABASE_URL` still overrides it.
+ */
+export declare const TEST_ADMIN_URL: string;
+export declare function withDatabase(url: string, name: string): string;
+export interface TestDatabase {
+  name: string;
+  url: string;
+  /** Drops the database. Safe to call once every connection to it is closed. */
+  drop: () => Promise<void>;
+}
+/**
+ * A fresh, migrated database for one test suite, cloned from the template.
+ *
+ * `prefix` names the suite in `pg_database`, which is what you grep for when a run was
+ * interrupted and left a database behind.
+ */
+export declare function createTestDatabase(prefix: string): Promise<TestDatabase>;
+//#endregion