@happyvertical/smrt-cli 0.53.3 → 0.53.5

package/dist/ProfileLinkCollection-4uNURz32-CbKZYmYm.js

@@ -0,0 +1,233 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { i as tenantId, r as TenantScoped } from "./dist-C87Ib9Vx.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
+import { SmrtCollection, SmrtObject, field, foreignKey, isEmbeddedDatabase, smrt, withEmbeddedWriteTransaction } from "@happyvertical/smrt-core";
+//#region ../profiles/dist/chunks/ProfileLinkCollection-4uNURz32.js
+var ProfileLinkCollection_4uNURz32_exports = /* @__PURE__ */ __exportAll({
+	a: () => PROFILE_LINK_MAX_URL_LENGTH,
+	c: () => isProfileLinkPlatform,
+	i: () => 200,
+	l: () => normalizeProfileLinkUrl,
+	n: () => ProfileLinkCollection,
+	o: () => PROFILE_LINK_PLATFORMS,
+	r: () => ProfileLinkCollection_exports,
+	s: () => ProfileLink,
+	t: () => 50
+});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var PROFILE_LINK_PLATFORMS = [
+	"facebook",
+	"instagram",
+	"x",
+	"linkedin",
+	"youtube",
+	"tiktok",
+	"website",
+	"other"
+];
+function isProfileLinkPlatform(value) {
+	return typeof value === "string" && PROFILE_LINK_PLATFORMS.includes(value);
+}
+function normalizeProfileLinkUrl(raw) {
+	const text = String(raw ?? "").trim();
+	if (!text) throw new Error("A profile link needs a web address");
+	if (text.length > 2048 || /\s/.test(text)) throw new Error("A profile link must be a single web address");
+	let url;
+	try {
+		url = new URL(text);
+	} catch {
+		throw new Error(`Not a web address: ${text}`);
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error("A profile link must start with http:// or https://");
+	if (url.username || url.password) throw new Error("A profile link cannot carry a user name or password");
+	if (!url.hostname) throw new Error(`Not a web address: ${text}`);
+	return url.toString();
+}
+var ProfileLink = class extends SmrtObject {
+	tenantId = null;
+	profileId = "";
+	platform = "website";
+	url = "";
+	label = null;
+	sortOrder = 0;
+	constructor(options = {}) {
+		super(options);
+		if (options.profileId) this.profileId = options.profileId;
+		if (options.platform) this.platform = options.platform;
+		if (options.url) this.url = options.url;
+		if (options.label !== void 0) this.label = options.label;
+		if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+	}
+	/**
+	* A link's address and label are not its identity: two people can link the
+	* same page, and one person can relabel a link. Without an explicit slug
+	* the default (label-derived) slug would make a new link adopt another row
+	* through the (tenant, slug, context) natural key, so a link's default slug
+	* is its id.
+	*/
+	async getSlug() {
+		if (!this.slug && this.id) this.slug = String(this.id);
+		return super.getSlug();
+	}
+	/** Validates and normalizes the link before it is written. */
+	async save(...args) {
+		if (!this.profileId) throw new Error("A profile link needs a profile");
+		if (!isProfileLinkPlatform(this.platform)) throw new Error(`Unknown profile link platform: ${this.platform}`);
+		this.url = normalizeProfileLinkUrl(this.url);
+		const label = this.label?.trim() ?? "";
+		if (label.length > 200) throw new Error("A profile link label is too long");
+		this.label = label || null;
+		if (!Number.isInteger(this.sortOrder) || this.sortOrder < 0) throw new Error("A profile link sortOrder must be a whole number ≥ 0");
+		return super.save(...args);
+	}
+};
+__decorateClass([tenantId({ nullable: true })], ProfileLink.prototype, "tenantId", 2);
+__decorateClass([foreignKey("Profile", {
+	required: true,
+	onDelete: "CASCADE"
+})], ProfileLink.prototype, "profileId", 2);
+__decorateClass([field({
+	required: true,
+	maxLength: 32
+})], ProfileLink.prototype, "platform", 2);
+__decorateClass([field({
+	required: true,
+	maxLength: 2048
+})], ProfileLink.prototype, "url", 2);
+__decorateClass([field({
+	nullable: true,
+	maxLength: 200
+})], ProfileLink.prototype, "label", 2);
+__decorateClass([field()], ProfileLink.prototype, "sortOrder", 2);
+ProfileLink = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableName: "profile_links",
+	api: false,
+	mcp: false,
+	cli: false
+})], ProfileLink);
+var ProfileLinkCollection_exports = /* @__PURE__ */ __exportAll$1({
+	PROFILE_LINK_LIMIT: () => 50,
+	ProfileLinkCollection: () => ProfileLinkCollection
+});
+var ProfileLinkCollection = class ProfileLinkCollection extends SmrtCollection {
+	static _itemClass = ProfileLink;
+	/** The profile's links in display order (sortOrder, then age). */
+	async listForProfile(profileId) {
+		if (!profileId) return [];
+		return (await this.list({ where: { profileId } })).sort(compareLinks);
+	}
+	/**
+	* Makes the profile's links exactly `links`, in that order, in one
+	* transaction: a link whose address is already on the profile keeps its row
+	* (and id), new addresses are added, and links left out are removed. The
+	* same address given twice is kept once, at its first position. New links
+	* take the profile's tenant. Throws, changing nothing, when the profile is
+	* not visible in the current tenant context or a link is invalid.
+	*/
+	async replaceForProfile(profileId, links) {
+		const wanted = normalizeInputs(links);
+		return this.inTransaction(async (bound) => {
+			const tenantId = await bound.requireProfileTenant(profileId);
+			const existing = await bound.listForProfile(profileId);
+			const byUrl = /* @__PURE__ */ new Map();
+			for (const link of existing) if (!byUrl.has(link.url)) byUrl.set(link.url, link);
+			const kept = /* @__PURE__ */ new Set();
+			const result = [];
+			for (const [index, input] of wanted.entries()) {
+				const current = byUrl.get(input.url);
+				if (current) {
+					kept.add(current);
+					const changed = current.platform !== input.platform || (current.label ?? null) !== input.label || current.sortOrder !== index || !current.tenantId && tenantId !== null;
+					current.platform = input.platform;
+					current.label = input.label;
+					current.sortOrder = index;
+					if (!current.tenantId && tenantId) current.tenantId = tenantId;
+					if (changed) await current.save();
+					result.push(current);
+					continue;
+				}
+				const created = await bound.create({
+					profileId,
+					platform: input.platform,
+					url: input.url,
+					label: input.label,
+					sortOrder: index,
+					...tenantId ? { tenantId } : {}
+				});
+				result.push(created);
+			}
+			for (const link of existing) if (!kept.has(link)) await link.delete();
+			return result;
+		});
+	}
+	/**
+	* Puts the profile's links in the order of `linkIds`, which must name every
+	* link on the profile exactly once. One transaction; throws, changing
+	* nothing, on a missing, extra or repeated id.
+	*/
+	async reorder(profileId, linkIds) {
+		return this.inTransaction(async (bound) => {
+			await bound.requireProfileTenant(profileId);
+			const existing = await bound.listForProfile(profileId);
+			const byId = new Map(existing.map((link) => [String(link.id), link]));
+			const ids = linkIds.map(String);
+			if (ids.length !== existing.length || new Set(ids).size !== ids.length || ids.some((id) => !byId.has(id))) throw new Error("Reorder must list every link on the profile exactly once");
+			const ordered = [];
+			for (const [index, id] of ids.entries()) {
+				const link = byId.get(id);
+				if (link.sortOrder !== index) {
+					link.sortOrder = index;
+					await link.save();
+				}
+				ordered.push(link);
+			}
+			return ordered;
+		});
+	}
+	/** The profile's tenant; throws when the profile is not visible here. */
+	async requireProfileTenant(profileId) {
+		if (!profileId) throw new Error("A profile link needs a profile");
+		const { ProfileCollection } = await import("./ProfileCollection-DuJT7Mum-nXbHrPpX.js").then((n) => n.o).then((n) => n.r);
+		const profile = await (await ProfileCollection.create({ db: this.db })).get({ id: profileId });
+		if (!profile) throw new Error(`Profile '${profileId}' not found`);
+		return profile.tenantId ?? null;
+	}
+	async inTransaction(work) {
+		const db = this.db;
+		return withEmbeddedWriteTransaction(db, isEmbeddedDatabase(db), async (transaction) => work(await ProfileLinkCollection.create({ db: transaction })));
+	}
+};
+function compareLinks(a, b) {
+	if (a.sortOrder !== b.sortOrder) return a.sortOrder - b.sortOrder;
+	const aTime = new Date(a.created_at ?? 0).getTime();
+	const bTime = new Date(b.created_at ?? 0).getTime();
+	if (aTime !== bTime) return aTime - bTime;
+	return String(a.id).localeCompare(String(b.id));
+}
+function normalizeInputs(links) {
+	if (links.length > 50) throw new Error(`A profile can hold at most 50 links (got ${links.length})`);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const link of links) {
+		if (!isProfileLinkPlatform(link.platform)) throw new Error(`Unknown profile link platform: ${link.platform}`);
+		const url = normalizeProfileLinkUrl(link.url);
+		if (seen.has(url)) continue;
+		seen.add(url);
+		out.push({
+			platform: link.platform,
+			url,
+			label: link.label?.trim() ? link.label.trim() : null
+		});
+	}
+	return out;
+}
+//#endregion
+export { isProfileLinkPlatform as a, ProfileLinkCollection_4uNURz32_exports as i, ProfileLink as n, normalizeProfileLinkUrl as o, ProfileLinkCollection as r, PROFILE_LINK_PLATFORMS as t };

package/dist/ProfileMetadataCollection-DQhbfEfa-_1rQCLTR.js

@@ -0,0 +1,108 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { i as tenantId, r as TenantScoped } from "./dist-C87Ib9Vx.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
+import { SmrtCollection, SmrtObject, field, foreignKey, smrt } from "@happyvertical/smrt-core";
+//#region ../profiles/dist/chunks/ProfileMetadataCollection-DQhbfEfa.js
+var ProfileMetadataCollection_DQhbfEfa_exports = /* @__PURE__ */ __exportAll({
+	n: () => ProfileMetadataCollection_exports,
+	r: () => ProfileMetadata,
+	t: () => ProfileMetadataCollection
+});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var ProfileMetadata = class extends SmrtObject {
+	tenantId = null;
+	profileId;
+	metafieldId;
+	value = "";
+	constructor(options = {}) {
+		super(options);
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.metafieldId !== void 0) this.metafieldId = options.metafieldId;
+		if (options.value) this.value = options.value;
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+	}
+	/**
+	* Validate this metadata value against the metafield's validation schema
+	*
+	* @returns True if valid, throws error if invalid
+	*/
+	async validate() {
+		const metafield = await this.loadRelated("metafieldId");
+		if (!metafield) throw new Error("Metafield not found");
+		return await metafield.validateValue(this.value);
+	}
+	/**
+	* Get the metafield slug for this metadata
+	*
+	* @returns The slug of the metafield
+	*/
+	async getMetafieldSlug() {
+		return (await this.loadRelated("metafieldId"))?.slug || "";
+	}
+};
+__decorateClass([tenantId({ nullable: true })], ProfileMetadata.prototype, "tenantId", 2);
+__decorateClass([foreignKey("Profile", { required: true })], ProfileMetadata.prototype, "profileId", 2);
+__decorateClass([foreignKey("ProfileMetafield", { required: true })], ProfileMetadata.prototype, "metafieldId", 2);
+__decorateClass([field({ required: true })], ProfileMetadata.prototype, "value", 2);
+ProfileMetadata = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update",
+		"delete"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], ProfileMetadata);
+var ProfileMetadataCollection_exports = /* @__PURE__ */ __exportAll$1({ ProfileMetadataCollection: () => ProfileMetadataCollection });
+var ProfileMetadataCollection = class extends SmrtCollection {
+	static _itemClass = ProfileMetadata;
+	/**
+	* Get all metadata for a profile
+	*
+	* @param profileId - The profile UUID
+	* @returns Array of ProfileMetadata instances
+	*/
+	async getByProfile(profileId) {
+		return await this.list({ where: { profileId } });
+	}
+	/**
+	* Get metadata as key-value object for a profile
+	*
+	* @param profileId - The profile UUID
+	* @returns Object with metafield slugs as keys
+	*/
+	async getMetadataObject(profileId) {
+		const metadata = await this.getByProfile(profileId);
+		const result = {};
+		for (const item of metadata) {
+			const slug = await item.getMetafieldSlug();
+			if (slug) result[slug] = item.value;
+		}
+		return result;
+	}
+	/**
+	* Find all profiles with a specific metadata key-value pair
+	*
+	* @param metafieldId - The metafield UUID
+	* @param value - The value to match
+	* @returns Array of profile UUIDs
+	*/
+	async findProfilesByMetadata(metafieldId, value) {
+		return (await this.list({ where: {
+			metafieldId,
+			value: String(value)
+		} })).map((m) => m.profileId).filter((id) => typeof id === "string");
+	}
+};
+//#endregion
+export { ProfileMetadataCollection as n, ProfileMetadataCollection_DQhbfEfa_exports as r, ProfileMetadata as t };

package/dist/ProfileMetafieldCollection-CoBuM_5G-CPjW3l5r.js

@@ -0,0 +1,145 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { i as tenantId, r as TenantScoped } from "./dist-C87Ib9Vx.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
+import { SmrtCollection, SmrtObject, field, smrt } from "@happyvertical/smrt-core";
+//#region ../profiles/dist/chunks/ProfileMetafieldCollection-CoBuM_5G.js
+var ProfileMetafieldCollection_CoBuM_5G_exports = /* @__PURE__ */ __exportAll({
+	n: () => ProfileMetafieldCollection_exports,
+	r: () => ProfileMetafield,
+	t: () => ProfileMetafieldCollection
+});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+function getCustomValidators() {
+	if (!globalThis.__smrtProfileMetafieldValidators) globalThis.__smrtProfileMetafieldValidators = /* @__PURE__ */ new Map();
+	return globalThis.__smrtProfileMetafieldValidators;
+}
+var ProfileMetafield = class extends SmrtObject {
+	tenantId = null;
+	name = "";
+	description;
+	validation;
+	constructor(options = {}) {
+		super(options);
+		if (options.name) this.name = options.name;
+		if (options.description !== void 0) this.description = options.description;
+		if (options.validation !== void 0) this.validation = options.validation;
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+	}
+	/**
+	* Convenience method for slug-based lookup
+	*
+	* @param slug - The slug to search for
+	* @returns ProfileMetafield instance or null if not found
+	*/
+	static async getBySlug(_slug) {
+		return null;
+	}
+	/**
+	* Register a custom validator function
+	*
+	* @param name - Name of the validator (used in validation.custom field)
+	* @param validator - The validator function
+	*/
+	static registerValidator(name, validator) {
+		getCustomValidators().set(name, validator);
+	}
+	/**
+	* Get a registered custom validator
+	*
+	* @param name - Name of the validator
+	* @returns The validator function or undefined
+	*/
+	static getValidator(name) {
+		return getCustomValidators().get(name);
+	}
+	/**
+	* Validate a value against this metafield's validation schema
+	*
+	* @param value - The value to validate
+	* @returns True if valid, throws ValidationError if invalid
+	*/
+	async validateValue(value) {
+		if (!this.validation) return true;
+		const schema = this.validation;
+		if (schema.type) {
+			const actualType = typeof value;
+			const expectedType = schema.type;
+			if (expectedType === "number" && actualType !== "number") throw new Error(schema.message || `Expected ${expectedType}, got ${actualType}`);
+			if (expectedType === "string" && actualType !== "string") throw new Error(schema.message || `Expected ${expectedType}, got ${actualType}`);
+			if (expectedType === "boolean" && actualType !== "boolean") throw new Error(schema.message || `Expected ${expectedType}, got ${actualType}`);
+		}
+		if (schema.pattern && typeof value === "string") {
+			if (!new RegExp(schema.pattern).test(value)) throw new Error(schema.message || "Pattern validation failed");
+		}
+		if (schema.minLength && typeof value === "string") {
+			if (value.length < schema.minLength) throw new Error(schema.message || `Minimum length is ${schema.minLength}, got ${value.length}`);
+		}
+		if (schema.maxLength && typeof value === "string") {
+			if (value.length > schema.maxLength) throw new Error(schema.message || `Maximum length is ${schema.maxLength}, got ${value.length}`);
+		}
+		if (schema.min !== void 0 && typeof value === "number") {
+			if (value < schema.min) throw new Error(schema.message || `Value must be at least ${schema.min}`);
+		}
+		if (schema.max !== void 0 && typeof value === "number") {
+			if (value > schema.max) throw new Error(schema.message || `Value must be at most ${schema.max}`);
+		}
+		if (schema.custom) {
+			const validator = ProfileMetafield.getValidator(schema.custom);
+			if (!validator) throw new Error(`Custom validator '${schema.custom}' not registered`);
+			if (!await validator(value)) throw new Error(schema.message || "Custom validation failed");
+		}
+		return true;
+	}
+};
+__decorateClass([tenantId({ nullable: true })], ProfileMetafield.prototype, "tenantId", 2);
+__decorateClass([field({ required: true })], ProfileMetafield.prototype, "name", 2);
+ProfileMetafield = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], ProfileMetafield);
+var ProfileMetafieldCollection_exports = /* @__PURE__ */ __exportAll$1({ ProfileMetafieldCollection: () => ProfileMetafieldCollection });
+var ProfileMetafieldCollection = class extends SmrtCollection {
+	static _itemClass = ProfileMetafield;
+	/**
+	* Get metafield by slug
+	*
+	* @param slug - The slug to search for
+	* @returns ProfileMetafield instance or null
+	*/
+	async getBySlug(slug) {
+		return await this.get({ slug });
+	}
+	/**
+	* Get or create a metafield by slug
+	*
+	* @param slug - The slug to search for
+	* @param defaults - Default values if creating
+	* @returns ProfileMetafield instance
+	*/
+	async getOrCreateBySlug(slug, defaults) {
+		const existing = await this.getBySlug(slug);
+		if (existing) return existing;
+		const metafield = await this.create({
+			slug,
+			...defaults
+		});
+		await metafield.save();
+		return metafield;
+	}
+};
+//#endregion
+export { ProfileMetafieldCollection as n, ProfileMetafieldCollection_CoBuM_5G_exports as r, ProfileMetafield as t };

package/dist/ProfileRelationshipCollection-DUVgaIqf-RCDqYz6O.js

@@ -0,0 +1,161 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { i as tenantId, r as TenantScoped } from "./dist-C87Ib9Vx.js";
+import { n as __exportAll$1 } from "./NostrIdentity-n70E0vck-Di3_eNCq.js";
+import { SmrtCollection, SmrtObject, foreignKey, oneToMany, smrt } from "@happyvertical/smrt-core";
+//#region ../profiles/dist/chunks/ProfileRelationshipCollection-DUVgaIqf.js
+var ProfileRelationshipCollection_DUVgaIqf_exports = /* @__PURE__ */ __exportAll({
+	n: () => ProfileRelationshipCollection_exports,
+	r: () => ProfileRelationship,
+	t: () => ProfileRelationshipCollection
+});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var ProfileRelationship = class extends SmrtObject {
+	tenantId = null;
+	fromProfileId;
+	toProfileId;
+	typeId;
+	contextProfileId;
+	terms = [];
+	constructor(options = {}) {
+		super(options);
+		if (options.fromProfileId !== void 0) this.fromProfileId = options.fromProfileId;
+		if (options.toProfileId !== void 0) this.toProfileId = options.toProfileId;
+		if (options.typeId !== void 0) this.typeId = options.typeId;
+		if (options.contextProfileId !== void 0) this.contextProfileId = options.contextProfileId;
+	}
+	/**
+	* Get the relationship type slug
+	*
+	* @returns The slug of the relationship type
+	*/
+	async getTypeSlug() {
+		return (await this.loadRelated("typeId"))?.slug || "";
+	}
+	/**
+	* Add a term (time period) to this relationship
+	*
+	* @param startedAt - Start date of the term
+	* @param endedAt - Optional end date of the term
+	*/
+	async addTerm(startedAt, endedAt) {
+		if (!this.id) throw new Error("ProfileRelationship.addTerm requires a persisted relationship (missing id)");
+		const relationshipId = this.id;
+		const { ProfileRelationshipTermCollection } = await import("./ProfileRelationshipTermCollection-DtA9OM23-BoGhQBSQ.js").then((n) => n.r).then((n) => n.n);
+		await (await (await ProfileRelationshipTermCollection.create(this.options)).create({
+			relationshipId,
+			startedAt,
+			endedAt
+		})).save();
+	}
+	/**
+	* End the current active term
+	*
+	* @param endedAt - End date for the term
+	*/
+	async endCurrentTerm(endedAt) {
+		const activeTerm = await this.getActiveTerm();
+		if (activeTerm) await activeTerm.end(endedAt);
+	}
+	/**
+	* Get all terms for this relationship
+	*
+	* @returns Array of ProfileRelationshipTerm instances
+	*/
+	async getTerms() {
+		const { ProfileRelationshipTermCollection } = await import("./ProfileRelationshipTermCollection-DtA9OM23-BoGhQBSQ.js").then((n) => n.r).then((n) => n.n);
+		return await (await ProfileRelationshipTermCollection.create(this.options)).getByRelationship(this.id);
+	}
+	/**
+	* Get the active term (no end date)
+	*
+	* @returns Current term or null if none active
+	*/
+	async getActiveTerm() {
+		const { ProfileRelationshipTermCollection } = await import("./ProfileRelationshipTermCollection-DtA9OM23-BoGhQBSQ.js").then((n) => n.r).then((n) => n.n);
+		return await (await ProfileRelationshipTermCollection.create(this.options)).getActiveTerm(this.id);
+	}
+};
+__decorateClass([tenantId({ nullable: true })], ProfileRelationship.prototype, "tenantId", 2);
+__decorateClass([foreignKey("Profile", { required: true })], ProfileRelationship.prototype, "fromProfileId", 2);
+__decorateClass([foreignKey("Profile", { required: true })], ProfileRelationship.prototype, "toProfileId", 2);
+__decorateClass([foreignKey("ProfileRelationshipType", { required: true })], ProfileRelationship.prototype, "typeId", 2);
+__decorateClass([foreignKey("Profile")], ProfileRelationship.prototype, "contextProfileId", 2);
+__decorateClass([oneToMany("ProfileRelationshipTerm")], ProfileRelationship.prototype, "terms", 2);
+ProfileRelationship = __decorateClass([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"delete"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], ProfileRelationship);
+var ProfileRelationshipCollection_exports = /* @__PURE__ */ __exportAll$1({ ProfileRelationshipCollection: () => ProfileRelationshipCollection });
+var ProfileRelationshipCollection = class extends SmrtCollection {
+	static _itemClass = ProfileRelationship;
+	/**
+	* Get all relationships from a profile
+	*
+	* @param fromProfileId - The origin profile UUID
+	* @param typeId - Optional filter by relationship type UUID
+	* @returns Array of ProfileRelationship instances
+	*/
+	async getFromProfile(fromProfileId, typeId) {
+		const where = { fromProfileId };
+		if (typeId) where.typeId = typeId;
+		return await this.list({ where });
+	}
+	/**
+	* Get all relationships to a profile
+	*
+	* @param toProfileId - The target profile UUID
+	* @param typeId - Optional filter by relationship type UUID
+	* @returns Array of ProfileRelationship instances
+	*/
+	async getToProfile(toProfileId, typeId) {
+		const where = { toProfileId };
+		if (typeId) where.typeId = typeId;
+		return await this.list({ where });
+	}
+	/**
+	* Get all relationships for a profile (both directions)
+	*
+	* @param profileId - The profile UUID
+	* @param typeId - Optional filter by relationship type UUID
+	* @returns Array of ProfileRelationship instances
+	*/
+	async getForProfile(profileId, typeId) {
+		const fromRelationships = await this.getFromProfile(profileId, typeId);
+		const toRelationships = await this.getToProfile(profileId, typeId);
+		return [...fromRelationships, ...toRelationships];
+	}
+	/**
+	* Check if a relationship exists between two profiles
+	*
+	* @param fromProfileId - The origin profile UUID
+	* @param toProfileId - The target profile UUID
+	* @param typeId - The relationship type UUID
+	* @returns True if relationship exists
+	*/
+	async exists(fromProfileId, toProfileId, typeId) {
+		return (await this.list({
+			where: {
+				fromProfileId,
+				toProfileId,
+				typeId
+			},
+			limit: 1
+		})).length > 0;
+	}
+};
+//#endregion
+export { ProfileRelationshipCollection as n, ProfileRelationshipCollection_DUVgaIqf_exports as r, ProfileRelationship as t };