@happyvertical/smrt-social 0.30.0

package/dist/index.js

@@ -0,0 +1,824 @@
+import { ObjectRegistry, smrt, SmrtObject, SmrtCollection, foreignKey, crossPackageRef, field } from "@happyvertical/smrt-core";
+import { tenantId, TenantScoped, getCurrentTenant, withTenant } from "@happyvertical/smrt-tenancy";
+import { randomUUID } from "node:crypto";
+import { SecretService } from "@happyvertical/smrt-secrets";
+import { getSocialPlatformSetup } from "./server.js";
+import { VideoContent } from "@happyvertical/smrt-video";
+ObjectRegistry.registerPackageManifest(
+  new URL("./manifest.json", import.meta.url)
+);
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(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$3(target, key, result);
+  return result;
+};
+let OAuthState = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Platform being connected
+   */
+  platform = "youtube";
+  /**
+   * CSRF state token
+   * This is sent to the OAuth provider and verified on callback
+   */
+  state = "";
+  /**
+   * PKCE code verifier
+   * Required for platforms using PKCE (YouTube, etc.)
+   */
+  codeVerifier = null;
+  /**
+   * Redirect URI used in the OAuth request
+   * Must match on callback for verification
+   */
+  redirectUri = "";
+  /**
+   * Requested OAuth scopes
+   */
+  scopes = [];
+  /**
+   * When this state expires
+   * States should be short-lived (10 minutes typical)
+   */
+  expiresAt = new Date(Date.now() + 10 * 60 * 1e3);
+  constructor(options = {}) {
+    super(options);
+    if (options.platform !== void 0) this.platform = options.platform;
+    if (options.state !== void 0) this.state = options.state;
+    if (options.codeVerifier !== void 0)
+      this.codeVerifier = options.codeVerifier;
+    if (options.redirectUri !== void 0)
+      this.redirectUri = options.redirectUri;
+    if (options.scopes !== void 0) this.scopes = options.scopes;
+    if (options.expiresAt !== void 0) this.expiresAt = options.expiresAt;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  /**
+   * Check if the state has expired
+   */
+  get isExpired() {
+    return Date.now() >= this.expiresAt.getTime();
+  }
+  /**
+   * Check if the state is still valid
+   */
+  get isValid() {
+    return !this.isExpired && this.state.length > 0;
+  }
+  /**
+   * Verify a callback state matches this record
+   */
+  verifyState(callbackState) {
+    return this.isValid && this.state === callbackState;
+  }
+  /**
+   * Generate a new random state token
+   */
+  static generateState() {
+    return crypto.randomUUID();
+  }
+  /**
+   * Generate a PKCE code verifier
+   * Returns a 43-128 character random string
+   */
+  static generateCodeVerifier() {
+    const array = new Uint8Array(32);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+      ""
+    );
+  }
+  /**
+   * Generate PKCE code challenge from verifier (S256 method)
+   * Note: This requires async crypto operations
+   */
+  static async generateCodeChallenge(verifier) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(verifier);
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    const base64 = btoa(String.fromCharCode(...new Uint8Array(digest)));
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+};
+__decorateClass$3([
+  tenantId({ nullable: true })
+], OAuthState.prototype, "tenantId", 2);
+OAuthState = __decorateClass$3([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "delete"]
+    },
+    mcp: false,
+    cli: true
+  })
+], OAuthState);
+class OAuthStateCollection extends SmrtCollection {
+  static _itemClass = OAuthState;
+  async findByState(state) {
+    return this.get({ state });
+  }
+  async findExpired(now = /* @__PURE__ */ new Date()) {
+    return this.list({
+      where: { "expiresAt <=": now },
+      orderBy: "expiresAt ASC"
+    });
+  }
+  async deleteExpired(now = /* @__PURE__ */ new Date()) {
+    const expired = await this.findExpired(now);
+    await Promise.all(expired.map((state) => state.delete()));
+    return expired.length;
+  }
+}
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(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$2(target, key, result);
+  return result;
+};
+let SocialAccount = class extends SmrtObject {
+  tenantId = null;
+  /**
+   * Human-readable name for the account
+   */
+  name = "";
+  /**
+   * Social platform type
+   */
+  platform = "youtube";
+  /**
+   * Platform-specific user ID
+   */
+  platformUserId = null;
+  /**
+   * Platform username/handle
+   */
+  platformUsername = null;
+  /**
+   * Profile URL on the platform
+   */
+  platformUrl = null;
+  /**
+   * Deprecated raw OAuth access token.
+   * Prefer credentialSecretId/accessTokenSecretName.
+   */
+  accessToken = null;
+  /**
+   * Deprecated raw OAuth refresh token.
+   * Prefer credentialSecretId/refreshTokenSecretName.
+   */
+  refreshToken = null;
+  /**
+   * Secret name containing the complete platform credential payload.
+   */
+  credentialSecretId = null;
+  /**
+   * Secret name containing only the access token.
+   */
+  accessTokenSecretName = null;
+  /**
+   * Secret name containing only the refresh token.
+   */
+  refreshTokenSecretName = null;
+  /**
+   * Token expiration time
+   */
+  tokenExpiresAt = null;
+  /**
+   * Whether the account is active
+   */
+  isActive = true;
+  /**
+   * Default hashtags to add to posts
+   */
+  defaultHashtags = [];
+  /**
+   * Granted OAuth scopes or platform permissions.
+   */
+  scopes = [];
+  /**
+   * Required permissions that still need app review or user grant.
+   */
+  missingPermissions = [];
+  /**
+   * How to handle links in posts
+   * - description: Include link in post body/description
+   * - reply: Post link as a reply (better for X algorithm)
+   * - none: Don't include link
+   */
+  linkBehavior = "description";
+  /**
+   * Safety mode for publish operations.
+   */
+  publishMode = "dry_run";
+  /**
+   * Separate latch required before public publishing is allowed.
+   */
+  publicPublishingAllowed = false;
+  /**
+   * Account connection status
+   */
+  status = "connected";
+  /**
+   * Error message if status is 'error'
+   */
+  errorMessage = null;
+  constructor(options = {}) {
+    super(options);
+    if (options.name !== void 0) this.name = options.name;
+    if (options.platform !== void 0) this.platform = options.platform;
+    if (options.platformUserId !== void 0)
+      this.platformUserId = options.platformUserId;
+    if (options.platformUsername !== void 0)
+      this.platformUsername = options.platformUsername;
+    if (options.platformUrl !== void 0)
+      this.platformUrl = options.platformUrl;
+    if (options.accessToken !== void 0)
+      this.accessToken = options.accessToken;
+    if (options.refreshToken !== void 0)
+      this.refreshToken = options.refreshToken;
+    if (options.credentialSecretId !== void 0)
+      this.credentialSecretId = options.credentialSecretId;
+    if (options.accessTokenSecretName !== void 0)
+      this.accessTokenSecretName = options.accessTokenSecretName;
+    if (options.refreshTokenSecretName !== void 0)
+      this.refreshTokenSecretName = options.refreshTokenSecretName;
+    if (options.tokenExpiresAt !== void 0)
+      this.tokenExpiresAt = options.tokenExpiresAt;
+    if (options.isActive !== void 0) this.isActive = options.isActive;
+    if (options.defaultHashtags !== void 0)
+      this.defaultHashtags = options.defaultHashtags;
+    if (options.scopes !== void 0) this.scopes = options.scopes;
+    if (options.missingPermissions !== void 0)
+      this.missingPermissions = options.missingPermissions;
+    if (options.linkBehavior !== void 0)
+      this.linkBehavior = options.linkBehavior;
+    if (options.publishMode !== void 0)
+      this.publishMode = options.publishMode;
+    if (options.publicPublishingAllowed !== void 0)
+      this.publicPublishingAllowed = options.publicPublishingAllowed;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.errorMessage !== void 0)
+      this.errorMessage = options.errorMessage;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.platform !== void 0) {
+      const setup = getSocialPlatformSetup(this.platform);
+      if (options.linkBehavior === void 0) {
+        this.linkBehavior = setup.defaultLinkBehavior;
+      }
+      if (options.publishMode === void 0) {
+        this.publishMode = setup.defaultPublishMode;
+      }
+    }
+  }
+  /**
+   * Social accounts need a slug identity that is scoped by tenant and platform.
+   * A newsroom may connect `@localnews` on X, YouTube, Threads, and Facebook;
+   * the generic name-derived slug would make those accounts overwrite each
+   * other through SMRT's slug/context upsert identity.
+   */
+  async getSlug() {
+    if (!this.slug) {
+      const identity = this.platformUserId || this.platformUsername || this.name || this.id;
+      if (!identity) {
+        return this.slug;
+      }
+      const source = [
+        this.tenantId ? `tenant-${this.tenantId}` : "no-tenant",
+        this.platform,
+        identity
+      ].filter(Boolean).join("-");
+      this.slug = source.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+    }
+    return this.slug;
+  }
+  /**
+   * Check if the token is expired or will expire soon
+   */
+  get isTokenExpired() {
+    if (!this.tokenExpiresAt) return false;
+    const expiryBuffer = 5 * 60 * 1e3;
+    return Date.now() >= this.tokenExpiresAt.getTime() - expiryBuffer;
+  }
+  /**
+   * Check if the account needs attention (expired or error)
+   */
+  get needsAttention() {
+    return this.status !== "connected" || this.isTokenExpired || this.missingPermissions.length > 0 || this.publishMode === "public" && !this.publicPublishingAllowed;
+  }
+  /**
+   * Check if the account is ready for publishing
+   */
+  get isReady() {
+    return this.isActive && this.status === "connected" && this.hasCredentials && this.missingPermissions.length === 0 && !this.isTokenExpired && (this.publishMode !== "public" || this.publicPublishingAllowed);
+  }
+  /**
+   * Effective publish mode after applying the public-publishing latch.
+   */
+  get effectivePublishMode() {
+    if (this.publishMode === "public" && !this.publicPublishingAllowed) {
+      return "dry_run";
+    }
+    return this.publishMode;
+  }
+  /**
+   * Check whether any usable credential reference exists.
+   */
+  get hasCredentials() {
+    return Boolean(
+      this.credentialSecretId || this.accessTokenSecretName || this.accessToken
+    );
+  }
+  /**
+   * Store all platform credentials in smrt-secrets as a single JSON payload.
+   */
+  async setCredentials(credentials, options = {}) {
+    if (!this.id) {
+      this.id = randomUUID();
+    }
+    const secretName = this.credentialSecretId ?? `social-account-${this.id}`;
+    const tenantId2 = this.requireCredentialTenantId(
+      "store social account credentials"
+    );
+    const secretService = await SecretService.create({ db: this.db });
+    await secretService.storeForTenant(
+      tenantId2,
+      secretName,
+      JSON.stringify(credentials),
+      {
+        description: options.description ?? `Credentials for ${this.name}`,
+        category: options.category ?? "social"
+      }
+    );
+    this.credentialSecretId = secretName;
+    await this.withCredentialTenantContext(async () => {
+      await this.save();
+    });
+  }
+  /**
+   * Retrieve platform credentials from smrt-secrets, falling back to deprecated fields.
+   */
+  async getCredentials() {
+    if (!this.credentialSecretId) {
+      if (this.accessTokenSecretName || this.refreshTokenSecretName) {
+        const tenantId3 = this.requireCredentialTenantId(
+          "retrieve social account credentials"
+        );
+        const secretService2 = await SecretService.create({ db: this.db });
+        const credentials = {};
+        if (this.accessTokenSecretName) {
+          const secret2 = await secretService2.retrieveForTenant(
+            tenantId3,
+            this.accessTokenSecretName
+          );
+          credentials.accessToken = secret2.value;
+        }
+        if (this.refreshTokenSecretName) {
+          const secret2 = await secretService2.retrieveForTenant(
+            tenantId3,
+            this.refreshTokenSecretName
+          );
+          credentials.refreshToken = secret2.value;
+        }
+        return credentials;
+      }
+      if (!this.accessToken && !this.refreshToken) return null;
+      return {
+        accessToken: this.accessToken,
+        refreshToken: this.refreshToken
+      };
+    }
+    const credentialSecretId = this.credentialSecretId;
+    const tenantId2 = this.requireCredentialTenantId(
+      "retrieve social account credentials"
+    );
+    const secretService = await SecretService.create({ db: this.db });
+    const secret = await secretService.retrieveForTenant(
+      tenantId2,
+      credentialSecretId
+    );
+    return JSON.parse(secret.value);
+  }
+  async withCredentialTenantContext(fn) {
+    const tenantId2 = this.getCredentialTenantId();
+    const currentTenantId = getCurrentTenant()?.tenantId;
+    if (!tenantId2 || currentTenantId === tenantId2) {
+      return fn();
+    }
+    return withTenant({ tenantId: tenantId2 }, fn);
+  }
+  getCredentialTenantId() {
+    if (this.tenantId) {
+      return this.tenantId;
+    }
+    return getCurrentTenant()?.tenantId ?? null;
+  }
+  requireCredentialTenantId(action) {
+    const tenantId2 = this.getCredentialTenantId();
+    if (!tenantId2) {
+      throw new Error(`Tenant context required to ${action}.`);
+    }
+    return tenantId2;
+  }
+};
+__decorateClass$2([
+  tenantId({ nullable: true })
+], SocialAccount.prototype, "tenantId", 2);
+SocialAccount = __decorateClass$2([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], SocialAccount);
+class SocialAccountCollection extends SmrtCollection {
+  static _itemClass = SocialAccount;
+  async findActive(platform) {
+    const accounts = await this.list({
+      where: {
+        isActive: true,
+        ...platform ? { platform } : {}
+      },
+      orderBy: "name ASC"
+    });
+    return accounts;
+  }
+  async findReady(platform) {
+    const accounts = await this.findActive(platform);
+    return accounts.filter((account) => account.isReady);
+  }
+  async findNeedsAttention() {
+    const accounts = await this.list({
+      where: { isActive: true },
+      orderBy: "name ASC"
+    });
+    return accounts.filter((account) => account.needsAttention);
+  }
+}
+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 SocialPost = class extends SmrtObject {
+  tenantId = null;
+  socialAccountId = null;
+  videoContentId = null;
+  contentId = null;
+  /**
+   * High-level post type
+   */
+  postType = "text";
+  /**
+   * Public media URL for platforms that require URL media publishing
+   */
+  mediaUrl = null;
+  /**
+   * Post title (for platforms that support it)
+   */
+  title = null;
+  /**
+   * Post description/caption
+   */
+  description = "";
+  /**
+   * Hashtags to include
+   */
+  hashtags = [];
+  /**
+   * Link URL to include in the post
+   */
+  linkUrl = null;
+  /**
+   * Platform-specific post ID (set after publishing)
+   */
+  platformPostId = null;
+  /**
+   * Public post URL (set after publishing)
+   */
+  platformUrl = null;
+  /**
+   * Scheduled publish time
+   * If set, post will be scheduled instead of published immediately
+   */
+  scheduledAt = null;
+  /**
+   * Actual publish time
+   */
+  publishedAt = null;
+  /**
+   * Post status
+   * - draft: Not yet submitted for publishing
+   * - pending_approval: Awaiting editorial approval
+   * - approved: Approved and ready to publish
+   * - scheduled: Queued for future publishing
+   * - publishing: Currently being published
+   * - dry_run: Payload was validated without remote write
+   * - staged: Non-public platform object/container was created
+   * - published: Successfully published
+   * - failed: Publishing failed
+   * - cancelled: Publishing was cancelled
+   */
+  status = "draft";
+  /**
+   * Error message if status is 'failed'
+   */
+  errorMessage = null;
+  /**
+   * Engagement analytics
+   */
+  analytics = {};
+  /**
+   * When analytics were last synced
+   */
+  analyticsLastSyncedAt = null;
+  constructor(options = {}) {
+    super(options);
+    if (options.socialAccountId !== void 0)
+      this.socialAccountId = options.socialAccountId;
+    if (options.videoContentId !== void 0)
+      this.videoContentId = options.videoContentId;
+    if (options.contentId !== void 0) this.contentId = options.contentId;
+    if (options.postType !== void 0) this.postType = options.postType;
+    if (options.mediaUrl !== void 0) this.mediaUrl = options.mediaUrl;
+    if (options.title !== void 0) this.title = options.title;
+    if (options.description !== void 0)
+      this.description = options.description;
+    if (options.hashtags !== void 0) this.hashtags = options.hashtags;
+    if (options.linkUrl !== void 0) this.linkUrl = options.linkUrl;
+    if (options.platformPostId !== void 0)
+      this.platformPostId = options.platformPostId;
+    if (options.platformUrl !== void 0)
+      this.platformUrl = options.platformUrl;
+    if (options.scheduledAt !== void 0)
+      this.scheduledAt = options.scheduledAt;
+    if (options.publishedAt !== void 0)
+      this.publishedAt = options.publishedAt;
+    if (options.status !== void 0) this.status = options.status;
+    if (options.errorMessage !== void 0)
+      this.errorMessage = options.errorMessage;
+    if (options.analytics !== void 0) this.analytics = options.analytics;
+    if (options.analyticsLastSyncedAt !== void 0)
+      this.analyticsLastSyncedAt = options.analyticsLastSyncedAt;
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+  }
+  /**
+   * Check if the post is scheduled for future publishing
+   */
+  get isScheduled() {
+    return this.status === "scheduled" && this.scheduledAt !== null;
+  }
+  /**
+   * Check if the post has been published
+   */
+  get isPublished() {
+    return this.status === "published";
+  }
+  /**
+   * Check if the post can be edited (draft or failed)
+   */
+  get isEditable() {
+    return this.status === "draft" || this.status === "pending_approval" || this.status === "failed";
+  }
+  /**
+   * Check if the post is due for publishing now.
+   */
+  get isDueForPublish() {
+    if (this.status !== "approved" && this.status !== "scheduled") {
+      return false;
+    }
+    return !this.scheduledAt || this.scheduledAt.getTime() <= Date.now();
+  }
+  /**
+   * Get formatted hashtag string
+   */
+  get hashtagString() {
+    return this.hashtags.map((tag) => tag.startsWith("#") ? tag : `#${tag}`).join(" ");
+  }
+  /**
+   * Get the full post text with hashtags
+   */
+  get fullText() {
+    const parts = [this.description];
+    if (this.hashtags.length > 0) {
+      parts.push(this.hashtagString);
+    }
+    return parts.join("\n\n");
+  }
+};
+__decorateClass$1([
+  tenantId({ nullable: true })
+], SocialPost.prototype, "tenantId", 2);
+__decorateClass$1([
+  foreignKey(() => SocialAccount)
+], SocialPost.prototype, "socialAccountId", 2);
+__decorateClass$1([
+  foreignKey(() => VideoContent)
+], SocialPost.prototype, "videoContentId", 2);
+__decorateClass$1([
+  crossPackageRef("@happyvertical/smrt-content:Content")
+], SocialPost.prototype, "contentId", 2);
+SocialPost = __decorateClass$1([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "update", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], SocialPost);
+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 SocialPostAnalyticsSnapshot = class extends SmrtObject {
+  tenantId = null;
+  socialPostId = null;
+  platform = null;
+  analytics = {};
+  raw = null;
+  capturedAt = /* @__PURE__ */ new Date();
+  constructor(options = {}) {
+    super(options);
+    if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+    if (options.socialPostId !== void 0)
+      this.socialPostId = options.socialPostId;
+    if (options.platform !== void 0) this.platform = options.platform;
+    if (options.analytics !== void 0) this.analytics = options.analytics;
+    if (options.raw !== void 0) this.raw = options.raw;
+    if (options.capturedAt !== void 0) this.capturedAt = options.capturedAt;
+  }
+};
+__decorateClass([
+  tenantId({ nullable: true })
+], SocialPostAnalyticsSnapshot.prototype, "tenantId", 2);
+__decorateClass([
+  foreignKey(() => SocialPost)
+], SocialPostAnalyticsSnapshot.prototype, "socialPostId", 2);
+__decorateClass([
+  field({ required: true })
+], SocialPostAnalyticsSnapshot.prototype, "platform", 2);
+__decorateClass([
+  field({ type: "json", nullable: true })
+], SocialPostAnalyticsSnapshot.prototype, "raw", 2);
+SocialPostAnalyticsSnapshot = __decorateClass([
+  TenantScoped({ mode: "optional" }),
+  smrt({
+    tableStrategy: "sti",
+    api: {
+      include: ["list", "get", "create", "delete"]
+    },
+    mcp: {
+      include: ["list", "get"]
+    },
+    cli: true
+  })
+], SocialPostAnalyticsSnapshot);
+function isRawAnalyticsPayload(value) {
+  return value === null || Array.isArray(value) || typeof value === "object" && value !== null;
+}
+class SocialPostAnalyticsSnapshotCollection extends SmrtCollection {
+  static _itemClass = SocialPostAnalyticsSnapshot;
+  async recordSnapshot(options) {
+    const snapshot = await this.create({
+      socialPostId: options.socialPostId,
+      platform: options.platform,
+      analytics: options.metrics,
+      raw: options.raw ?? (isRawAnalyticsPayload(options.metrics.raw) ? options.metrics.raw : null),
+      capturedAt: options.capturedAt ?? /* @__PURE__ */ new Date(),
+      tenantId: options.tenantId
+    });
+    return snapshot;
+  }
+  async findForPost(socialPostId) {
+    return this.list({
+      where: { socialPostId },
+      orderBy: "capturedAt DESC"
+    });
+  }
+  async findLatestForPost(socialPostId) {
+    const snapshots = await this.findForPost(socialPostId);
+    return snapshots[0] ?? null;
+  }
+}
+class SocialPostCollection extends SmrtCollection {
+  static _itemClass = SocialPost;
+  async createDraft(options) {
+    return this.create({
+      ...options,
+      postType: options.postType ?? (options.videoContentId || options.mediaUrl ? "video" : options.linkUrl ? "link" : "text"),
+      status: options.scheduledAt ? "scheduled" : "draft"
+    });
+  }
+  async findByStatus(status) {
+    return this.list({ where: { status }, orderBy: "scheduledAt ASC" });
+  }
+  async findForAccount(socialAccountId) {
+    return this.list({
+      where: { socialAccountId },
+      orderBy: "created_at DESC"
+    });
+  }
+  async findDueForPublish(now = /* @__PURE__ */ new Date()) {
+    const [approved, scheduled] = await Promise.all([
+      this.list({
+        where: { status: "approved" },
+        orderBy: "scheduledAt ASC"
+      }),
+      this.list({
+        where: { status: "scheduled", "scheduledAt <=": now },
+        orderBy: "scheduledAt ASC"
+      })
+    ]);
+    return [
+      ...approved.filter((post) => post.isDueForPublish),
+      ...scheduled
+    ].sort(
+      (a, b) => (a.scheduledAt?.getTime() ?? 0) - (b.scheduledAt?.getTime() ?? 0)
+    );
+  }
+  async recordPublishSuccess(post, data) {
+    const status = data.status ?? "published";
+    post.platformPostId = data.platformPostId;
+    post.platformUrl = data.platformUrl;
+    if (status === "published") {
+      post.publishedAt = data.publishedAt ?? post.publishedAt ?? /* @__PURE__ */ new Date();
+    }
+    post.status = status;
+    post.errorMessage = null;
+    await post.save();
+    return post;
+  }
+  async recordPublishFailure(post, error) {
+    post.status = "failed";
+    post.errorMessage = formatPublishError(error);
+    await post.save();
+    return post;
+  }
+  async updateLatestAnalytics(post, analytics, syncedAt = /* @__PURE__ */ new Date()) {
+    post.analytics = {
+      ...analytics,
+      lastUpdated: analytics.lastUpdated ?? syncedAt
+    };
+    post.analyticsLastSyncedAt = syncedAt;
+    await post.save();
+    return post;
+  }
+}
+function formatPublishError(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  const details = [error.message];
+  const code = error.code;
+  if (code !== void 0) {
+    details.push(`code=${String(code)}`);
+  }
+  if (error.stack) {
+    details.push(error.stack);
+  }
+  return details.join("\n");
+}
+export {
+  OAuthState,
+  OAuthStateCollection,
+  SocialAccount,
+  SocialAccountCollection,
+  SocialPost,
+  SocialPostAnalyticsSnapshot,
+  SocialPostAnalyticsSnapshotCollection,
+  SocialPostCollection
+};
+//# sourceMappingURL=index.js.map