convex-cms 0.0.1

package/dist/component/taxonomies.d.ts

@@ -0,0 +1,476 @@
+/**
+ * Taxonomy Query Functions
+ *
+ * Provides query functions for retrieving taxonomy definitions and terms.
+ * Taxonomies are classification systems (like tags, categories, topics) that
+ * can be applied to content entries for organization and filtering.
+ *
+ * Available queries:
+ * - `get`: Retrieve a single taxonomy by ID or name
+ * - `list`: List all taxonomies with optional filtering
+ * - `getTerm`: Retrieve a single term by ID or slug
+ * - `listTerms`: List terms within a taxonomy with filtering and search
+ * - `getTermsByEntry`: Get all terms associated with a content entry
+ * - `getEntriesByTerm`: Get content entries associated with a term
+ * - `suggestTerms`: Get term suggestions based on partial input
+ */
+/**
+ * Query to retrieve a single taxonomy by ID or name.
+ *
+ * @param id - The taxonomy ID for direct lookup (most efficient)
+ * @param name - The machine-readable name for index-based lookup
+ * @param includeDeleted - Whether to return soft-deleted taxonomies (default: false)
+ *
+ * @returns The taxonomy document, or null if not found
+ *
+ * @example
+ * ```typescript
+ * // Get by ID
+ * const taxonomy = await ctx.runQuery(api.taxonomies.get, { id: taxonomyId });
+ *
+ * // Get by name
+ * const tagsTaxonomy = await ctx.runQuery(api.taxonomies.get, { name: "tags" });
+ * ```
+ */
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    id?: import("convex/values").GenericId<"taxonomies"> | undefined;
+    name?: string | undefined;
+    includeDeleted?: boolean | undefined;
+}, Promise<{
+    _id: import("convex/values").GenericId<"taxonomies">;
+    _creationTime: number;
+    description?: string | undefined;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    sortOrder?: number | undefined;
+    icon?: string | undefined;
+    name: string;
+    displayName: string;
+    isActive: boolean;
+    isHierarchical: boolean;
+    allowInlineCreation: boolean;
+} | null>>;
+/**
+ * Query to list all taxonomies with optional filtering.
+ *
+ * @param isActive - Filter by active status
+ * @param isHierarchical - Filter by hierarchical type
+ * @param includeDeleted - Whether to include soft-deleted taxonomies
+ * @param paginationOpts - Standard Convex pagination options
+ *
+ * @returns Paginated list of taxonomy documents
+ *
+ * @example
+ * ```typescript
+ * // List all active taxonomies
+ * const taxonomies = await ctx.runQuery(api.taxonomies.list, {
+ *   isActive: true,
+ *   paginationOpts: { numItems: 20 },
+ * });
+ *
+ * // List only flat taxonomies (like tags)
+ * const flatTaxonomies = await ctx.runQuery(api.taxonomies.list, {
+ *   isHierarchical: false,
+ *   paginationOpts: { numItems: 20 },
+ * });
+ * ```
+ */
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    isActive?: boolean | undefined;
+    isHierarchical?: boolean | undefined;
+    paginationOpts?: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    } | undefined;
+    includeDeleted?: boolean | undefined;
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"taxonomies">;
+        _creationTime: number;
+        description?: string | undefined;
+        deletedAt?: number | undefined;
+        createdBy?: string | undefined;
+        updatedBy?: string | undefined;
+        sortOrder?: number | undefined;
+        icon?: string | undefined;
+        name: string;
+        displayName: string;
+        isActive: boolean;
+        isHierarchical: boolean;
+        allowInlineCreation: boolean;
+    }[];
+    continueCursor: import("convex/values").GenericId<"taxonomies"> | null;
+    isDone: boolean;
+}>>;
+/**
+ * Query to retrieve a single taxonomy term by ID or slug.
+ *
+ * @param id - The term ID for direct lookup
+ * @param taxonomyId - The taxonomy ID (required when looking up by slug)
+ * @param slug - The term slug for lookup within a taxonomy
+ * @param includeDeleted - Whether to return soft-deleted terms
+ *
+ * @returns The term document, or null if not found
+ */
+export declare const getTerm: import("convex/server").RegisteredQuery<"public", {
+    id?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+    taxonomyId?: import("convex/values").GenericId<"taxonomies"> | undefined;
+    slug?: string | undefined;
+    includeDeleted?: boolean | undefined;
+}, Promise<{
+    _id: import("convex/values").GenericId<"taxonomyTerms">;
+    _creationTime: number;
+    description?: string | undefined;
+    parentId?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+    path?: string | undefined;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    sortOrder?: number | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+    name: string;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+    slug: string;
+    depth: number;
+    usageCount: number;
+} | null>>;
+/**
+ * Query to list terms within a taxonomy.
+ *
+ * @param taxonomyId - The taxonomy to list terms from (required)
+ * @param parentId - Filter by parent term (for hierarchical navigation)
+ * @param rootOnly - Only return root-level terms (depth = 0)
+ * @param search - Search terms by name
+ * @param includeDeleted - Whether to include soft-deleted terms
+ * @param sortBy - Sort field: "name", "usageCount", "sortOrder"
+ * @param sortDirection - Sort direction
+ * @param paginationOpts - Standard Convex pagination options
+ *
+ * @returns Paginated list of term documents
+ *
+ * @example
+ * ```typescript
+ * // List all tags in a taxonomy
+ * const tags = await ctx.runQuery(api.taxonomies.listTerms, {
+ *   taxonomyId: tagsTaxonomyId,
+ *   paginationOpts: { numItems: 50 },
+ * });
+ *
+ * // List root categories only
+ * const rootCategories = await ctx.runQuery(api.taxonomies.listTerms, {
+ *   taxonomyId: categoriesTaxonomyId,
+ *   rootOnly: true,
+ *   paginationOpts: { numItems: 20 },
+ * });
+ *
+ * // List children of a category
+ * const children = await ctx.runQuery(api.taxonomies.listTerms, {
+ *   taxonomyId: categoriesTaxonomyId,
+ *   parentId: parentCategoryId,
+ *   paginationOpts: { numItems: 20 },
+ * });
+ *
+ * // Sort by popularity (usage count)
+ * const popularTags = await ctx.runQuery(api.taxonomies.listTerms, {
+ *   taxonomyId: tagsTaxonomyId,
+ *   sortBy: "usageCount",
+ *   sortDirection: "desc",
+ *   paginationOpts: { numItems: 20 },
+ * });
+ * ```
+ */
+export declare const listTerms: import("convex/server").RegisteredQuery<"public", {
+    parentId?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+    paginationOpts?: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    } | undefined;
+    includeDeleted?: boolean | undefined;
+    search?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    sortBy?: "name" | "sortOrder" | "usageCount" | undefined;
+    rootOnly?: boolean | undefined;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"taxonomyTerms">;
+        _creationTime: number;
+        description?: string | undefined;
+        parentId?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+        path?: string | undefined;
+        deletedAt?: number | undefined;
+        createdBy?: string | undefined;
+        updatedBy?: string | undefined;
+        searchText?: string | undefined;
+        sortOrder?: number | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        name: string;
+        taxonomyId: import("convex/values").GenericId<"taxonomies">;
+        slug: string;
+        depth: number;
+        usageCount: number;
+    }[];
+    continueCursor: import("convex/values").GenericId<"taxonomyTerms"> | null;
+    isDone: boolean;
+}>>;
+/**
+ * Query to get all terms in a taxonomy as a hierarchical tree structure.
+ *
+ * This is useful for rendering nested category selectors or tree views.
+ * Returns terms with their children nested in a tree structure.
+ *
+ * @param taxonomyId - The taxonomy to get terms from
+ * @param includeDeleted - Whether to include soft-deleted terms
+ *
+ * @returns Array of root terms with nested children
+ *
+ * @example
+ * ```typescript
+ * const tree = await ctx.runQuery(api.taxonomies.getTermsHierarchy, {
+ *   taxonomyId: categoriesTaxonomyId,
+ * });
+ * // Returns: [
+ * //   { name: "Tech", children: [{ name: "Web Dev", children: [...] }] },
+ * //   { name: "Design", children: [...] },
+ * // ]
+ * ```
+ */
+export declare const getTermsHierarchy: import("convex/server").RegisteredQuery<"public", {
+    includeDeleted?: boolean | undefined;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+}, Promise<any[]>>;
+/**
+ * Query to get term suggestions based on partial input.
+ *
+ * This is useful for autocomplete functionality when users are selecting
+ * or creating tags. Returns matching terms sorted by relevance and usage.
+ *
+ * @param taxonomyId - The taxonomy to search within
+ * @param query - The partial input to match against term names
+ * @param limit - Maximum number of suggestions to return (default: 10)
+ * @param excludeIds - Term IDs to exclude from suggestions (already selected)
+ *
+ * @returns Array of matching terms
+ *
+ * @example
+ * ```typescript
+ * const suggestions = await ctx.runQuery(api.taxonomies.suggestTerms, {
+ *   taxonomyId: tagsTaxonomyId,
+ *   query: "java",
+ *   limit: 5,
+ *   excludeIds: alreadySelectedTagIds,
+ * });
+ * // Returns: [{ name: "JavaScript" }, { name: "Java" }, { name: "JavaFX" }]
+ * ```
+ */
+export declare const suggestTerms: import("convex/server").RegisteredQuery<"public", {
+    limit?: number | undefined;
+    excludeIds?: import("convex/values").GenericId<"taxonomyTerms">[] | undefined;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+    query: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"taxonomyTerms">;
+    _creationTime: number;
+    description?: string | undefined;
+    parentId?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+    path?: string | undefined;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    sortOrder?: number | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+    name: string;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+    slug: string;
+    depth: number;
+    usageCount: number;
+}[]>>;
+/**
+ * Query to get all taxonomy terms associated with a content entry.
+ *
+ * @param entryId - The content entry ID
+ * @param taxonomyId - Optional taxonomy filter
+ * @param fieldName - Optional field name filter
+ *
+ * @returns Array of terms associated with the entry
+ *
+ * @example
+ * ```typescript
+ * // Get all tags for an entry
+ * const entryTags = await ctx.runQuery(api.taxonomies.getTermsByEntry, {
+ *   entryId: blogPostId,
+ * });
+ *
+ * // Get only tags from a specific field
+ * const primaryTags = await ctx.runQuery(api.taxonomies.getTermsByEntry, {
+ *   entryId: blogPostId,
+ *   fieldName: "tags",
+ * });
+ * ```
+ */
+export declare const getTermsByEntry: import("convex/server").RegisteredQuery<"public", {
+    taxonomyId?: import("convex/values").GenericId<"taxonomies"> | undefined;
+    fieldName?: string | undefined;
+    entryId: import("convex/values").GenericId<"contentEntries">;
+}, Promise<{
+    fieldName: string;
+    sortOrder: number | undefined;
+    _id: import("convex/values").GenericId<"taxonomyTerms">;
+    _creationTime: number;
+    description?: string | undefined;
+    parentId?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+    path?: string | undefined;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+    name: string;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+    slug: string;
+    depth: number;
+    usageCount: number;
+}[]>>;
+/**
+ * Query to get content entries that have a specific term.
+ *
+ * @param termId - The term ID to search for
+ * @param status - Optional entry status filter
+ * @param paginationOpts - Standard Convex pagination options
+ *
+ * @returns Paginated list of entry IDs with the term
+ *
+ * @example
+ * ```typescript
+ * // Get all entries with a specific tag
+ * const entriesWithTag = await ctx.runQuery(api.taxonomies.getEntriesByTerm, {
+ *   termId: javascriptTagId,
+ *   status: "published",
+ *   paginationOpts: { numItems: 20 },
+ * });
+ * ```
+ */
+export declare const getEntriesByTerm: import("convex/server").RegisteredQuery<"public", {
+    status?: "draft" | "published" | "archived" | "scheduled" | undefined;
+    paginationOpts?: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    } | undefined;
+    termId: import("convex/values").GenericId<"taxonomyTerms">;
+}, Promise<{
+    page: import("convex/values").GenericId<"contentEntries">[];
+    continueCursor: import("convex/values").GenericId<"contentEntries"> | null;
+    isDone: boolean;
+}>>;
+/**
+ * Query to count terms in a taxonomy.
+ *
+ * @param taxonomyId - The taxonomy to count terms in
+ * @param includeDeleted - Whether to include soft-deleted terms
+ *
+ * @returns Object containing the count
+ */
+export declare const countTerms: import("convex/server").RegisteredQuery<"public", {
+    includeDeleted?: boolean | undefined;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+}, Promise<{
+    count: number;
+}>>;
+/**
+ * Query to get all taxonomy terms associated with a media asset.
+ *
+ * @param mediaId - The media asset ID
+ * @param taxonomyId - Optional taxonomy filter
+ *
+ * @returns Array of terms associated with the media asset
+ *
+ * @example
+ * ```typescript
+ * // Get all terms for a media asset
+ * const mediaTags = await ctx.runQuery(api.taxonomies.getTermsByMedia, {
+ *   mediaId: imageId,
+ * });
+ *
+ * // Get only terms from a specific taxonomy
+ * const categories = await ctx.runQuery(api.taxonomies.getTermsByMedia, {
+ *   mediaId: imageId,
+ *   taxonomyId: categoriesTaxonomyId,
+ * });
+ * ```
+ */
+export declare const getTermsByMedia: import("convex/server").RegisteredQuery<"public", {
+    taxonomyId?: import("convex/values").GenericId<"taxonomies"> | undefined;
+    mediaId: import("convex/values").GenericId<"mediaItems">;
+}, Promise<{
+    sortOrder: number | undefined;
+    _id: import("convex/values").GenericId<"taxonomyTerms">;
+    _creationTime: number;
+    description?: string | undefined;
+    parentId?: import("convex/values").GenericId<"taxonomyTerms"> | undefined;
+    path?: string | undefined;
+    deletedAt?: number | undefined;
+    createdBy?: string | undefined;
+    updatedBy?: string | undefined;
+    searchText?: string | undefined;
+    icon?: string | undefined;
+    color?: string | undefined;
+    name: string;
+    taxonomyId: import("convex/values").GenericId<"taxonomies">;
+    slug: string;
+    depth: number;
+    usageCount: number;
+}[]>>;
+/**
+ * Query to get media assets that have a specific term.
+ *
+ * @param termId - The term ID to search for
+ * @param includeDeleted - Whether to include soft-deleted media
+ * @param paginationOpts - Standard Convex pagination options
+ *
+ * @returns Paginated list of media asset IDs with the term
+ *
+ * @example
+ * ```typescript
+ * // Get all media with a specific category
+ * const mediaWithCategory = await ctx.runQuery(api.taxonomies.getMediaByTerm, {
+ *   termId: landscapeCategoryId,
+ *   paginationOpts: { numItems: 20 },
+ * });
+ * ```
+ */
+export declare const getMediaByTerm: import("convex/server").RegisteredQuery<"public", {
+    paginationOpts?: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    } | undefined;
+    includeDeleted?: boolean | undefined;
+    termId: import("convex/values").GenericId<"taxonomyTerms">;
+}, Promise<{
+    page: import("convex/values").GenericId<"mediaItems">[];
+    continueCursor: import("convex/values").GenericId<"mediaItems"> | null;
+    isDone: boolean;
+}>>;
+//# sourceMappingURL=taxonomies.d.ts.map

package/dist/component/taxonomies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taxonomies.d.ts","sourceRoot":"","sources":["../../src/component/taxonomies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgCH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;UAmCd,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0Ef,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;UAsClB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHpB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB;;;kBAkD5B,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;KAyDvB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;KAkD1B,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;GAwE3B,CAAC;AAMH;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;GAsBrB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;KAuC1B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;GA6DzB,CAAC"}