convex-cms 0.0.15 → 0.0.16

package/admin/dist/types/src/component/contentEntryMutations.d.ts

@@ -0,0 +1,551 @@
+/**
+ * Content Entry Mutation Functions
+ *
+ * Provides mutation functions for creating, updating, and deleting content entries.
+ * Content entries are instances of content types that hold the actual content data.
+ *
+ * Content Lifecycle:
+ * 1. Content starts as "draft" status by default
+ * 2. Draft content can be edited freely without affecting any published version
+ * 3. Publishing changes status to "published" and records publish timestamps
+ * 4. Unpublishing reverts status to "draft" for further editing
+ */
+/**
+ * Mutation to create a new content entry.
+ *
+ * Content entries are created with "draft" status by default. This allows
+ * content to be edited and refined before being published to the live site.
+ *
+ * The mutation will:
+ * 1. Validate that the content type exists
+ * 2. Generate a slug from the title field (or use provided slug)
+ * 3. Ensure the slug is unique within the content type
+ * 4. Create the entry with draft status (unless specified otherwise)
+ *
+ * @param contentTypeName - The name of the content type this entry belongs to (e.g., "blog_post")
+ * @param data - The content data (validated against content type schema at runtime)
+ * @param slug - Optional custom slug (auto-generated from title if not provided)
+ * @param locale - Optional locale code for localized content
+ * @param primaryEntryId - Reference to primary entry if this is a localized variant
+ * @param status - Initial status (defaults to "draft")
+ * @param createdBy - Optional user ID for audit trail
+ *
+ * @returns The created content entry
+ *
+ * @throws Error if the content type does not exist
+ * @throws Error if the content type is not active
+ *
+ * @example
+ * ```typescript
+ * // Create a new blog post (starts as draft)
+ * const post = await ctx.runMutation(api.contentEntryMutations.createEntry, {
+ *   contentTypeName: "blog_post",
+ *   data: {
+ *     title: "My First Post",
+ *     content: "<p>Hello world!</p>",
+ *   },
+ *   createdBy: currentUserId,
+ * });
+ *
+ * // Create with explicit status
+ * const scheduledPost = await ctx.runMutation(api.contentEntryMutations.createEntry, {
+ *   contentTypeName: "blog_post",
+ *   data: { title: "Scheduled Post" },
+ *   status: "scheduled",
+ *   scheduledPublishAt: Date.now() + 86400000, // Tomorrow
+ * });
+ * ```
+ */
+export declare const createEntry: import("convex/server").RegisteredMutation<"public", {
+    status?: string | undefined;
+    createdBy?: string | undefined;
+    slug?: string | undefined;
+    locale?: string | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    data: any;
+    contentTypeName: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    updatedBy?: string | undefined;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    deletedAt?: number | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+/**
+ * Mutation to update an existing content entry.
+ *
+ * Re-validates content against the type schema, optionally regenerates slug,
+ * and updates the modification timestamp. Updates are allowed regardless of status:
+ * - Draft entries: All fields can be updated freely
+ * - Published entries: Updates create a new "working draft" that doesn't
+ *   affect the live version until republished
+ * - Scheduled entries: Updates modify the scheduled content
+ *
+ * Key behaviors:
+ * 1. **Content Validation**: When data is provided, it's merged with existing data
+ *    and validated against the content type schema. Invalid data throws an error.
+ * 2. **Slug Handling**: Explicit slug takes precedence. If `regenerateSlug` is true
+ *    and data is updated, the slug is regenerated from the slugField value.
+ * 3. **Search Text**: Automatically regenerated from searchable fields when data changes.
+ * 4. **Version Tracking**: Version number is incremented on every update.
+ *
+ * @param id - The content entry ID to update
+ * @param slug - Optional new slug (uniqueness will be validated)
+ * @param data - Optional new content data (merged with existing, then validated)
+ * @param status - Optional new status
+ * @param scheduledPublishAt - Optional scheduled publish time (for "scheduled" status)
+ * @param updatedBy - Optional user ID for audit trail
+ * @param regenerateSlug - If true, regenerates slug from slugField when data is updated
+ *
+ * @returns The updated content entry
+ *
+ * @throws Error if the entry does not exist
+ * @throws Error if the entry has been deleted
+ * @throws Error if the content type has been deleted
+ * @throws Error if content validation fails
+ * @throws Error if the new slug is not unique
+ *
+ * @example
+ * ```typescript
+ * // Update content data (validates against schema)
+ * await ctx.runMutation(api.contentEntryMutations.updateEntry, {
+ *   id: entryId,
+ *   data: { title: "Updated Title", content: "<p>New content</p>" },
+ *   updatedBy: currentUserId,
+ * });
+ *
+ * // Change slug explicitly
+ * await ctx.runMutation(api.contentEntryMutations.updateEntry, {
+ *   id: entryId,
+ *   slug: "new-url-slug",
+ * });
+ *
+ * // Update title and regenerate slug from it
+ * await ctx.runMutation(api.contentEntryMutations.updateEntry, {
+ *   id: entryId,
+ *   data: { title: "My New Blog Post Title" },
+ *   regenerateSlug: true,
+ *   updatedBy: currentUserId,
+ * });
+ * ```
+ */
+export declare const updateEntry: import("convex/server").RegisteredMutation<"public", {
+    updatedBy?: string | undefined;
+    data?: any;
+    status?: string | undefined;
+    slug?: string | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    scheduledPublishAt?: number | undefined;
+    regenerateSlug?: boolean | undefined;
+    id: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    updatedBy?: string | undefined;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    deletedAt?: number | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+/**
+ * Mutation to publish a content entry.
+ *
+ * Publishing transitions an entry from "draft" (or "scheduled") to "published"
+ * status, making it visible on the live site.
+ *
+ * When publishing:
+ * - Status is set to "published"
+ * - firstPublishedAt is set if this is the first publication
+ * - lastPublishedAt is updated to current timestamp
+ * - Version is incremented
+ * - A version snapshot can be created (if versioning is enabled)
+ *
+ * @param id - The content entry ID to publish
+ * @param changeDescription - Optional description of changes (for version history)
+ * @param updatedBy - Optional user ID for audit trail
+ *
+ * @returns The published content entry
+ *
+ * @throws Error if the entry does not exist
+ * @throws Error if the entry has been deleted
+ * @throws Error if the entry is already published
+ *
+ * @example
+ * ```typescript
+ * const published = await ctx.runMutation(api.contentEntryMutations.publishEntry, {
+ *   id: entryId,
+ *   changeDescription: "Initial publication",
+ *   updatedBy: currentUserId,
+ * });
+ * ```
+ */
+export declare const publishEntry: import("convex/server").RegisteredMutation<"public", {
+    changeDescription?: string | undefined;
+    updatedBy?: string | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    id: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    updatedBy?: string | undefined;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    deletedAt?: number | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+/**
+ * Mutation to unpublish a content entry (revert to draft).
+ *
+ * Unpublishing transitions an entry from "published" back to "draft" status,
+ * removing it from the live site while preserving all content for further editing.
+ *
+ * This is useful for:
+ * - Taking content offline temporarily
+ * - Making significant changes before republishing
+ * - Seasonal content that needs to be hidden
+ *
+ * @param id - The content entry ID to unpublish
+ * @param updatedBy - Optional user ID for audit trail
+ *
+ * @returns The unpublished content entry (now in draft status)
+ *
+ * @throws Error if the entry does not exist
+ * @throws Error if the entry has been deleted
+ * @throws Error if the entry is not currently published
+ *
+ * @example
+ * ```typescript
+ * const draft = await ctx.runMutation(api.contentEntryMutations.unpublishEntry, {
+ *   id: entryId,
+ *   updatedBy: currentUserId,
+ * });
+ * console.log(draft.status); // "draft"
+ * ```
+ */
+export declare const unpublishEntry: import("convex/server").RegisteredMutation<"public", {
+    updatedBy?: string | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    id: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    updatedBy?: string | undefined;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    deletedAt?: number | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+/**
+ * Result type for delete operations.
+ * Returns the deleted entry with updated deletedAt timestamp.
+ */
+export declare const deleteResultDoc: import("convex/values").VObject<{
+    updatedBy?: string | undefined;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    deletedAt?: number | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    deletedVersionsCount?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    _creationTime: number;
+    version: number;
+    _id: import("convex/values").GenericId<"contentEntries">;
+}, {
+    /** Number of associated versions that were cleaned up */
+    deletedVersionsCount: import("convex/values").VFloat64<number | undefined, "optional">;
+    contentTypeName: import("convex/values").VString<string, "required">;
+    slug: import("convex/values").VString<string, "required">;
+    status: import("convex/values").VString<string, "required">;
+    data: import("convex/values").VAny<any, "required", string>;
+    locale: import("convex/values").VString<string | undefined, "optional">;
+    primaryEntryId: import("convex/values").VId<import("convex/values").GenericId<"contentEntries"> | undefined, "optional">;
+    version: import("convex/values").VFloat64<number, "required">;
+    scheduledPublishAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    firstPublishedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    lastPublishedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    lockedBy: import("convex/values").VString<string | undefined, "optional">;
+    lockExpiresAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    deletedAt: import("convex/values").VFloat64<number | undefined, "optional">;
+    createdBy: import("convex/values").VString<string | undefined, "optional">;
+    updatedBy: import("convex/values").VString<string | undefined, "optional">;
+    searchText: import("convex/values").VString<string | undefined, "optional">;
+    _id: import("convex/values").VId<import("convex/values").GenericId<"contentEntries">, "required">;
+    _creationTime: import("convex/values").VFloat64<number, "required">;
+}, "required", "updatedBy" | "data" | "status" | "createdBy" | "contentTypeName" | "slug" | "locale" | "primaryEntryId" | "scheduledPublishAt" | "lockedBy" | "_creationTime" | "deletedAt" | "searchText" | "version" | "firstPublishedAt" | "lastPublishedAt" | "lockExpiresAt" | `data.${string}` | "_id" | "deletedVersionsCount">;
+/**
+ * Mutation to delete a content entry.
+ *
+ * By default, performs a soft delete by setting the `deletedAt` timestamp.
+ * This allows the entry to be recovered later if needed.
+ *
+ * When `hardDelete` is true, permanently removes the entry and all
+ * associated version snapshots from the database.
+ *
+ * @param id - The content entry ID to delete
+ * @param deletedBy - Optional user ID for audit trail
+ * @param hardDelete - If true, permanently deletes entry and versions (default: false)
+ *
+ * @returns The deleted content entry (with deletedAt set for soft deletes)
+ *
+ * @throws Error if the entry does not exist
+ * @throws Error if the entry has already been deleted (for soft deletes)
+ *
+ * @example
+ * ```typescript
+ * // Soft delete (default) - entry can be recovered
+ * const deleted = await ctx.runMutation(api.contentEntryMutations.deleteEntry, {
+ *   id: entryId,
+ *   deletedBy: currentUserId,
+ * });
+ *
+ * // Hard delete - permanently removes entry and all versions
+ * await ctx.runMutation(api.contentEntryMutations.deleteEntry, {
+ *   id: entryId,
+ *   deletedBy: currentUserId,
+ *   hardDelete: true,
+ * });
+ * ```
+ */
+export declare const deleteEntry: import("convex/server").RegisteredMutation<"public", {
+    deletedBy?: string | undefined;
+    hardDelete?: boolean | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    id: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    deletedAt: number;
+    updatedBy: string | undefined;
+    deletedVersionsCount: number;
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+/**
+ * Mutation to restore a soft-deleted content entry.
+ *
+ * Removes the `deletedAt` timestamp from the entry, making it active again.
+ * Only works for soft-deleted entries; hard-deleted entries cannot be recovered.
+ *
+ * @param id - The content entry ID to restore
+ * @param restoredBy - Optional user ID for audit trail
+ *
+ * @returns The restored content entry
+ *
+ * @throws Error if the entry does not exist
+ * @throws Error if the entry is not soft-deleted
+ *
+ * @example
+ * ```typescript
+ * const restored = await ctx.runMutation(api.contentEntryMutations.restoreEntry, {
+ *   id: entryId,
+ *   restoredBy: currentUserId,
+ * });
+ * ```
+ */
+export declare const restoreEntry: import("convex/server").RegisteredMutation<"public", {
+    restoredBy?: string | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    id: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    deletedAt: undefined;
+    updatedBy: string | undefined;
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+/**
+ * Mutation to duplicate (clone) an existing content entry.
+ *
+ * Creates a new content entry with the same data as the source entry,
+ * but with a new unique slug. The duplicated entry is always created
+ * as a draft, regardless of the source entry's status.
+ *
+ * This is useful for:
+ * - Content templating workflows (copy a template to create new content)
+ * - Creating localized variants of content
+ * - Quick duplication of similar content pieces
+ *
+ * Key behaviors:
+ * 1. **Data Cloning**: All content data is deep-copied to the new entry
+ * 2. **Media References**: By default, media references (IDs) are copied,
+ *    pointing to the same media assets. Set `copyMediaReferences: false`
+ *    to clear media fields in the duplicate.
+ * 3. **Slug Generation**: A new unique slug is generated from the source
+ *    entry's slug (e.g., "my-post" → "my-post-1") unless a custom slug
+ *    is provided.
+ * 4. **Status Reset**: The duplicate always starts as "draft" with version 1
+ * 5. **Timestamps Reset**: Publishing timestamps are cleared in the duplicate
+ *
+ * @param sourceEntryId - The ID of the content entry to duplicate
+ * @param slug - Optional custom slug (auto-generated if not provided)
+ * @param copyMediaReferences - Whether to copy media IDs (default: true)
+ * @param locale - Optional locale for the duplicated entry
+ * @param createdBy - Optional user ID for audit trail
+ *
+ * @returns The newly created duplicate content entry
+ *
+ * @throws Error if the source entry does not exist
+ * @throws Error if the source entry has been deleted
+ * @throws Error if the content type does not exist or is not active
+ *
+ * @example
+ * ```typescript
+ * // Simple duplication (keeps all media references)
+ * const duplicate = await ctx.runMutation(api.contentEntryMutations.duplicateEntry, {
+ *   sourceEntryId: originalPostId,
+ *   createdBy: currentUserId,
+ * });
+ *
+ * // Duplicate with custom slug
+ * const duplicate = await ctx.runMutation(api.contentEntryMutations.duplicateEntry, {
+ *   sourceEntryId: templateId,
+ *   slug: "new-post-from-template",
+ *   createdBy: currentUserId,
+ * });
+ *
+ * // Duplicate without media references (for a fresh start)
+ * const duplicate = await ctx.runMutation(api.contentEntryMutations.duplicateEntry, {
+ *   sourceEntryId: originalPostId,
+ *   copyMediaReferences: false,
+ *   createdBy: currentUserId,
+ * });
+ * ```
+ */
+export declare const duplicateEntry: import("convex/server").RegisteredMutation<"public", {
+    createdBy?: string | undefined;
+    slug?: string | undefined;
+    locale?: string | undefined;
+    _auth?: {
+        resourceOwnerId?: string | undefined;
+        role: string | null;
+        userId: string;
+    } | undefined;
+    copyMediaReferences?: boolean | undefined;
+    sourceEntryId: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    _id: import("convex/values").GenericId<"contentEntries">;
+    _creationTime: number;
+    updatedBy?: string | undefined;
+    createdBy?: string | undefined;
+    locale?: string | undefined;
+    primaryEntryId?: import("convex/values").GenericId<"contentEntries"> | undefined;
+    scheduledPublishAt?: number | undefined;
+    lockedBy?: string | undefined;
+    deletedAt?: number | undefined;
+    searchText?: string | undefined;
+    firstPublishedAt?: number | undefined;
+    lastPublishedAt?: number | undefined;
+    lockExpiresAt?: number | undefined;
+    data: any;
+    status: string;
+    contentTypeName: string;
+    slug: string;
+    version: number;
+}>>;
+//# sourceMappingURL=contentEntryMutations.d.ts.map

package/admin/dist/types/src/component/contentEntryMutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentEntryMutations.d.ts","sourceRoot":"","sources":["../../../../../src/component/contentEntryMutations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAgDH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwItB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmNtB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFvB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DzB,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;IAE3B,yDAAyD;;;;;;;;;;;;;;;;;;;;sUAExD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuGtB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DvB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqKzB,CAAC"}