@happyvertical/smrt-properties 0.30.0

package/dist/index.js

@@ -0,0 +1,776 @@
+import { ObjectRegistry, crossPackageRef, smrt, SmrtObject, SmrtCollection, foreignKey, SmrtHierarchical } from "@happyvertical/smrt-core";
+import { definePrompt, resolvePrompt } from "@happyvertical/smrt-prompts";
+import { tenantId, TenantScoped } from "@happyvertical/smrt-tenancy";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+const smrtPropertiesSummarizePrompt = definePrompt({
+  key: "smrtProperties.property.summarize",
+  template: `Summarize this digital property:
+Name: {propertyName}
+Domain: {propertyDomain}
+Description: {propertyDescription}
+Status: {propertyStatus}
+Total zones: {totalZones}
+Top-level zones: {topLevelZones}`,
+  editable: {
+    template: true,
+    profile: true,
+    model: true,
+    params: true
+  }
+});
+function promptMessageOptions(ai) {
+  return {
+    ...ai.params || {},
+    ...ai.model ? { model: ai.model } : {},
+    ...typeof ai.temperature === "number" ? { temperature: ai.temperature } : {},
+    ...typeof ai.maxTokens === "number" ? { maxTokens: ai.maxTokens } : {}
+  };
+}
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(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$1(target, key, result);
+  return result;
+};
+let Property = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Display name of the property
+   */
+  name = "";
+  /**
+   * Domain name (e.g., "oakcreeknews.com")
+   */
+  domain = "";
+  /**
+   * Full URL (e.g., "https://oakcreeknews.com")
+   */
+  url = "";
+  /**
+   * Property description
+   */
+  description = "";
+  repositoryId = null;
+  ownerId = null;
+  /**
+   * Property status
+   */
+  status = "active";
+  /**
+   * Extensible metadata (analytics IDs, config, etc.)
+   */
+  metadata = {};
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.domain !== void 0) this.domain = options.domain;
+    if (options.url !== void 0) this.url = options.url;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.repositoryId !== void 0)
+      this.repositoryId = options.repositoryId;
+    if (options.ownerId !== void 0) this.ownerId = options.ownerId;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Get all zones for this property
+   */
+  async getZones() {
+    if (!this.id) return [];
+    const { ZoneCollection: ZoneCollection2 } = await Promise.resolve().then(() => Zones);
+    const collection = await ZoneCollection2.create(this.options);
+    return await collection.findByProperty(this.id);
+  }
+  /**
+   * Get zone tree for this property
+   */
+  async getZoneTree() {
+    if (!this.id) return { propertyId: "", roots: [] };
+    const { ZoneCollection: ZoneCollection2 } = await Promise.resolve().then(() => Zones);
+    const collection = await ZoneCollection2.create(this.options);
+    return await collection.getTree(this.id);
+  }
+  /**
+   * Create a zone on this property
+   */
+  async createZone(options) {
+    if (!this.id) {
+      throw new Error("Property must be saved before creating zones");
+    }
+    const { ZoneCollection: ZoneCollection2 } = await Promise.resolve().then(() => Zones);
+    const collection = await ZoneCollection2.create(this.options);
+    const zone = await collection.create({
+      ...options,
+      propertyId: this.id
+    });
+    await zone.save();
+    return zone;
+  }
+  /**
+   * Check if property is active
+   */
+  isActive() {
+    return this.status === "active";
+  }
+  /**
+   * AI-powered: Generate a summary of the property and its zones.
+   *
+   * Uses the `smrtProperties.property.summarize` prompt registered via
+   * `@happyvertical/smrt-prompts`, allowing tenant- or instance-level
+   * overrides of the template, model, and parameters at runtime.
+   *
+   * Only non-PII fields (name, domain, description, status) plus aggregate
+   * zone information are sent to the AI provider. Internal foreign-key
+   * fields and the extensible `metadata` blob are intentionally excluded.
+   *
+   * @returns Generated summary text
+   */
+  async summarize() {
+    const zones = await this.getZones();
+    const topLevelZones = zones.filter((z) => z.parentId === null);
+    const db = this.options.db ?? this.options.persistence;
+    const resolvedPrompt = await resolvePrompt(
+      smrtPropertiesSummarizePrompt.key,
+      {
+        db,
+        tenantId: this.tenantId,
+        variables: {
+          propertyName: this.name || "",
+          propertyDomain: this.domain || "",
+          propertyDescription: this.description || "",
+          propertyStatus: this.status || "",
+          totalZones: String(zones.length),
+          topLevelZones: topLevelZones.map((z) => z.name).join(", ")
+        }
+      }
+    );
+    const ai = await this.getAiClient();
+    const response = await ai.message(
+      resolvedPrompt.text,
+      promptMessageOptions(resolvedPrompt.ai)
+    );
+    return response.trim();
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], Property.prototype, "tenantId", 2);
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-projects:Repository")
+], Property.prototype, "repositoryId", 2);
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-profiles:Profile")
+], Property.prototype, "ownerId", 2);
+Property = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], Property);
+class PropertyCollection extends SmrtCollection {
+  static _itemClass = Property;
+  /**
+   * Find a property by domain
+   *
+   * @param domain - Domain name
+   * @returns Property or null
+   */
+  async findByDomain(domain) {
+    const results = await this.list({
+      where: { domain },
+      limit: 1
+    });
+    return results[0] || null;
+  }
+  /**
+   * Find properties by repository ID
+   *
+   * @param repositoryId - Repository ID
+   * @returns Array of properties
+   */
+  async findByRepository(repositoryId) {
+    return await this.list({
+      where: { repositoryId }
+    });
+  }
+  /**
+   * Find properties by owner ID
+   *
+   * @param ownerId - Owner profile ID
+   * @returns Array of properties
+   */
+  async findByOwner(ownerId) {
+    return await this.list({
+      where: { ownerId }
+    });
+  }
+  /**
+   * Find active properties
+   *
+   * @returns Array of active properties
+   */
+  async findActive() {
+    return await this.list({
+      where: { status: "active" }
+    });
+  }
+  /**
+   * Find properties by status
+   *
+   * @param status - Property status
+   * @returns Array of properties with the given status
+   */
+  async findByStatus(status) {
+    return await this.list({
+      where: { status }
+    });
+  }
+  /**
+   * Get or create a property by domain
+   *
+   * @param domain - Domain name
+   * @param defaults - Default values for creation
+   * @returns Property (existing or newly created)
+   */
+  async getOrCreateByDomain(domain, defaults = {}) {
+    let property = await this.findByDomain(domain);
+    if (!property) {
+      property = await this.create({
+        domain,
+        name: defaults.name || domain,
+        url: defaults.url || `https://${domain}`,
+        repositoryId: defaults.repositoryId ?? null,
+        ownerId: defaults.ownerId ?? null,
+        status: "active"
+      });
+      await property.save();
+    }
+    return property;
+  }
+  /**
+   * Count properties by status
+   *
+   * @returns Object with counts per status
+   */
+  async countByStatus() {
+    const all = await this.list({});
+    const counts = {
+      active: 0,
+      inactive: 0,
+      pending: 0
+    };
+    for (const prop of all) {
+      counts[prop.status]++;
+    }
+    return counts;
+  }
+  // ============================================
+  // Tenant Helper Methods
+  // ============================================
+  /**
+   * Find properties belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of properties for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global properties (no tenant association)
+   *
+   * @returns Array of global properties
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find properties for a tenant including global properties
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of tenant-specific and global properties
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Properties = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PropertyCollection
+}, Symbol.toStringTag, { value: "Module" }));
+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;
+};
+let Zone = class extends SmrtHierarchical {
+  tenantId = null;
+  propertyId = "";
+  // parentId inherited from SmrtHierarchical (null = top-level zone)
+  /**
+   * Display name
+   */
+  name = "";
+  /**
+   * Zone type (descriptive, not structural)
+   * Common values: "page", "section", "slot", "container", "widget"
+   */
+  type = "";
+  /**
+   * URL path pattern (e.g., "/", "/articles/*")
+   */
+  path = "";
+  /**
+   * CSS selector for placement (e.g., "#header", ".sidebar")
+   */
+  selector = "";
+  /**
+   * Position hint (e.g., "top", "after-paragraph-3")
+   */
+  position = "";
+  /**
+   * Width in pixels (null = fluid)
+   */
+  width = null;
+  /**
+   * Height in pixels (null = fluid)
+   */
+  height = null;
+  /**
+   * Allowed content/ad formats
+   */
+  allowedFormats = [];
+  /**
+   * Default content/asset ID for fallback
+   */
+  defaultContentId = null;
+  /**
+   * Extensible metadata
+   */
+  metadata = {};
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.propertyId !== void 0) this.propertyId = options.propertyId;
+    if (options.parentId !== void 0) this.parentId = options.parentId;
+    if (options.name !== void 0) this.name = options.name;
+    if (options.type !== void 0) this.type = options.type;
+    if (options.path !== void 0) this.path = options.path;
+    if (options.selector !== void 0) this.selector = options.selector;
+    if (options.position !== void 0) this.position = options.position;
+    if (options.width !== void 0) this.width = options.width;
+    if (options.height !== void 0) this.height = options.height;
+    if (options.allowedFormats !== void 0)
+      this.allowedFormats = options.allowedFormats;
+    if (options.defaultContentId !== void 0)
+      this.defaultContentId = options.defaultContentId;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+  /**
+   * Check if this is a top-level zone (no parent)
+   */
+  isTopLevel() {
+    return this.parentId === null;
+  }
+  /**
+   * Check if this zone has dimensions set
+   */
+  hasDimensions() {
+    return this.width !== null && this.height !== null;
+  }
+  /**
+   * Get dimensions as string (e.g., "728x90")
+   */
+  getDimensionString() {
+    if (!this.hasDimensions()) return null;
+    return `${this.width}x${this.height}`;
+  }
+  /**
+   * Get the parent property
+   */
+  async getProperty() {
+    const { PropertyCollection: PropertyCollection2 } = await Promise.resolve().then(() => Properties);
+    const collection = await PropertyCollection2.create(this.options);
+    return await collection.get({ id: this.propertyId });
+  }
+  // Hierarchy traversal (getParent / getChildren / getAncestors /
+  // getDescendants / getHierarchy / moveTo) provided by SmrtHierarchical.
+  // The collection-level depth cache in `ZoneCollection.getAncestors` /
+  // `getDescendants` remains available for callers that go through the
+  // collection — the base-class methods do their own batched queries.
+  /**
+   * Get the full path from root to this zone
+   */
+  async getFullPath() {
+    const ancestors = await this.getAncestors();
+    const names = [...ancestors.map((z) => z.name), this.name];
+    return names.join(" > ");
+  }
+  /**
+   * Get the depth in the hierarchy (0 = top-level)
+   */
+  async getDepth() {
+    const ancestors = await this.getAncestors();
+    return ancestors.length;
+  }
+  /**
+   * Create a child zone under this zone
+   */
+  async createChild(options) {
+    if (!this.id) {
+      throw new Error("Zone must be saved before creating children");
+    }
+    const { ZoneCollection: ZoneCollection2 } = await Promise.resolve().then(() => Zones);
+    const collection = await ZoneCollection2.create(this.options);
+    const zone = await collection.create({
+      ...options,
+      propertyId: this.propertyId,
+      parentId: this.id
+    });
+    await zone.save();
+    return zone;
+  }
+  /**
+   * Build tree node for this zone and its children
+   */
+  async toTreeNode() {
+    const children = await this.getChildren();
+    const childNodes = await Promise.all(children.map((c) => c.toTreeNode()));
+    return {
+      zone: this,
+      children: childNodes
+    };
+  }
+  /**
+   * Check if a format is allowed in this zone
+   */
+  isFormatAllowed(format) {
+    if (this.allowedFormats.length === 0) return true;
+    return this.allowedFormats.includes(format);
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], Zone.prototype, "tenantId", 2);
+__decorateClass([
+  foreignKey("Property")
+], Zone.prototype, "propertyId", 2);
+Zone = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    api: { include: ["list", "get", "create", "update", "delete"] },
+    mcp: { include: ["list", "get", "create"] },
+    cli: true
+  })
+], Zone);
+class ZoneCollection extends SmrtCollection {
+  static _itemClass = Zone;
+  /**
+   * Find all zones for a property
+   *
+   * @param propertyId - Property ID
+   * @returns Array of zones
+   */
+  async findByProperty(propertyId) {
+    return await this.list({
+      where: { propertyId }
+    });
+  }
+  /**
+   * Find top-level zones for a property (no parent)
+   *
+   * @param propertyId - Property ID
+   * @returns Array of top-level zones
+   */
+  async findTopLevel(propertyId) {
+    return await this.list({
+      where: { propertyId, parentId: null }
+    });
+  }
+  /**
+   * Find direct children of a zone
+   *
+   * @param parentId - Parent zone ID
+   * @returns Array of child zones
+   */
+  async findChildren(parentId) {
+    return await this.list({
+      where: { parentId }
+    });
+  }
+  /**
+   * Find zones by path pattern
+   *
+   * @param propertyId - Property ID
+   * @param path - URL path to match
+   * @returns Array of matching zones
+   */
+  async findByPath(propertyId, path) {
+    return await this.list({
+      where: { propertyId, path }
+    });
+  }
+  /**
+   * Find zones by type
+   *
+   * @param propertyId - Property ID
+   * @param type - Zone type
+   * @returns Array of zones of the given type
+   */
+  async findByType(propertyId, type) {
+    return await this.list({
+      where: { propertyId, type }
+    });
+  }
+  /**
+   * Get the complete zone tree for a property
+   *
+   * @param propertyId - Property ID
+   * @returns ZoneTree structure
+   */
+  async getTree(propertyId) {
+    const allZones = await this.findByProperty(propertyId);
+    const zoneMap = /* @__PURE__ */ new Map();
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const zone of allZones) {
+      if (zone.id) {
+        zoneMap.set(zone.id, zone);
+      }
+      if (!childrenMap.has(zone.parentId || "")) {
+        childrenMap.set(zone.parentId || "", []);
+      }
+      childrenMap.get(zone.parentId || "")?.push(zone);
+    }
+    const buildNode = (zone) => {
+      const children = (zone.id ? childrenMap.get(zone.id) : []) || [];
+      return {
+        zone,
+        children: children.map(buildNode)
+      };
+    };
+    const roots = childrenMap.get("") || [];
+    return {
+      propertyId,
+      roots: roots.map(buildNode)
+    };
+  }
+  /**
+   * Get all ancestors of a zone (path to root)
+   *
+   * @param zoneId - Zone ID
+   * @returns Array of ancestors (from root to parent)
+   */
+  async getAncestors(zoneId) {
+    const ancestors = [];
+    const startZone = await this.get({ id: zoneId });
+    if (!startZone) return ancestors;
+    let currentId = startZone.parentId;
+    while (currentId) {
+      const parent = await this.get({ id: currentId });
+      if (!parent) break;
+      ancestors.unshift(parent);
+      currentId = parent.parentId;
+    }
+    return ancestors;
+  }
+  /**
+   * Get all descendants of a zone recursively
+   *
+   * @param zoneId - Zone ID
+   * @returns Array of all descendant zones
+   */
+  async getDescendants(zoneId) {
+    const descendants = [];
+    const queue = [zoneId];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (!currentId) continue;
+      const children = await this.findChildren(currentId);
+      for (const child of children) {
+        descendants.push(child);
+        if (child.id) {
+          queue.push(child.id);
+        }
+      }
+    }
+    return descendants;
+  }
+  /**
+   * Get the depth of the deepest zone in a property
+   *
+   * @param propertyId - Property ID
+   * @returns Maximum depth (0 = only top-level zones)
+   */
+  async getMaxDepth(propertyId) {
+    const allZones = await this.findByProperty(propertyId);
+    const zonesById = /* @__PURE__ */ new Map();
+    for (const zone of allZones) {
+      if (zone.id) {
+        zonesById.set(zone.id, zone);
+      }
+    }
+    const depthCache = /* @__PURE__ */ new Map();
+    const getDepth = (zone) => {
+      if (!zone.id) return 0;
+      const cached = depthCache.get(zone.id);
+      if (cached !== void 0) return cached;
+      let depth = 0;
+      let current = zone;
+      const visited = /* @__PURE__ */ new Set();
+      while (current?.id) {
+        const parentId = current.parentId;
+        if (!parentId) break;
+        if (visited.has(parentId)) break;
+        visited.add(parentId);
+        const parent = zonesById.get(parentId);
+        if (!parent) break;
+        depth += 1;
+        current = parent;
+      }
+      depthCache.set(zone.id, depth);
+      return depth;
+    };
+    let maxDepth = 0;
+    for (const zone of allZones) {
+      maxDepth = Math.max(maxDepth, getDepth(zone));
+    }
+    return maxDepth;
+  }
+  /**
+   * Find zones with specific dimensions
+   *
+   * @param propertyId - Property ID
+   * @param width - Required width
+   * @param height - Required height
+   * @returns Array of matching zones
+   */
+  async findByDimensions(propertyId, width, height) {
+    return await this.list({
+      where: { propertyId, width, height }
+    });
+  }
+  /**
+   * Find zones that allow a specific format
+   *
+   * @param propertyId - Property ID
+   * @param format - Format to check
+   * @returns Array of zones allowing the format
+   */
+  async findByAllowedFormat(propertyId, format) {
+    const allZones = await this.findByProperty(propertyId);
+    return allZones.filter((zone) => zone.isFormatAllowed(format));
+  }
+  /**
+   * Move a zone to a new parent
+   *
+   * @param zoneId - Zone ID to move
+   * @param newParentId - New parent ID (null for top-level)
+   * @returns Updated zone
+   */
+  async moveZone(zoneId, newParentId) {
+    const zone = await this.get({ id: zoneId });
+    if (!zone) return null;
+    if (newParentId) {
+      const descendants = await this.getDescendants(zoneId);
+      const descendantIds = descendants.map((d) => d.id);
+      if (descendantIds.includes(newParentId)) {
+        throw new Error("Cannot move zone into one of its descendants");
+      }
+    }
+    zone.parentId = newParentId;
+    await zone.save();
+    return zone;
+  }
+  /**
+   * Delete a zone and optionally its descendants
+   *
+   * @param zoneId - Zone ID to delete
+   * @param cascade - Whether to delete descendants
+   * @returns Number of zones deleted
+   */
+  async deleteZone(zoneId, cascade = false) {
+    const zone = await this.get({ id: zoneId });
+    if (!zone) return 0;
+    let deleted = 0;
+    if (cascade) {
+      const descendants = await this.getDescendants(zoneId);
+      for (const desc of descendants) {
+        await desc.delete();
+        deleted++;
+      }
+    } else {
+      const children = await this.findChildren(zoneId);
+      for (const child of children) {
+        child.parentId = zone.parentId;
+        await child.save();
+      }
+    }
+    await zone.delete();
+    deleted++;
+    return deleted;
+  }
+  // ============================================
+  // Tenant Helper Methods
+  // ============================================
+  /**
+   * Find zones belonging to a specific tenant
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of zones for the tenant
+   */
+  async findByTenant(tenantId2) {
+    return this.list({ where: { tenantId: tenantId2 } });
+  }
+  /**
+   * Find global zones (no tenant association)
+   *
+   * @returns Array of global zones
+   */
+  async findGlobal() {
+    return this.list({ where: { tenantId: null } });
+  }
+  /**
+   * Find zones for a tenant including global zones
+   *
+   * @param tenantId - Tenant ID to filter by
+   * @returns Array of tenant-specific and global zones
+   */
+  async findWithGlobals(tenantId2) {
+    return this.query(
+      `SELECT * FROM ${this.tableName} WHERE tenant_id = ? OR tenant_id IS NULL`,
+      [tenantId2]
+    );
+  }
+}
+const Zones = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ZoneCollection
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Property,
+  PropertyCollection,
+  Zone,
+  ZoneCollection,
+  promptMessageOptions,
+  smrtPropertiesSummarizePrompt
+};
+//# sourceMappingURL=index.js.map