convex-cms 0.0.16 → 0.0.17

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

@@ -1,551 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}