@zachariaz/strapi-plugin-content-variants 0.1.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Plugin bootstrap lifecycle.
+ *
+ * Registers:
+ * 1. A Koa middleware that parses `segment` / `includeVariants` from the query
+ *    string, stashes them in `ctx.state`, and sets cache-friendly headers.
+ * 2. A Document Service middleware that intercepts findMany / findOne to:
+ *    - Filter out variant clone documents from list results
+ *    - Resolve variant fields when `segment` is present
+ *    - Embed `_variants` array when `includeVariants=true`
+ *    - Walk populated relations to resolve/enrich nested variant-enabled entities
+ */
+import type { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    default: {};
+    validator(config: Record<string, unknown>): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,121 @@
+declare const _default: {
+    segment: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {};
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                };
+                slug: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                };
+                description: {
+                    type: string;
+                };
+                externalId: {
+                    type: string;
+                };
+            };
+        };
+    };
+    'variant-link': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                baseContentType: {
+                    type: string;
+                    required: boolean;
+                };
+                baseDocumentId: {
+                    type: string;
+                    required: boolean;
+                };
+                variantDocumentId: {
+                    type: string;
+                    required: boolean;
+                };
+                label: {
+                    type: string;
+                };
+                assignments: {
+                    type: string;
+                    relation: string;
+                    target: string;
+                    mappedBy: string;
+                };
+            };
+        };
+    };
+    'variant-assignment': {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                variantLink: {
+                    type: string;
+                    relation: string;
+                    target: string;
+                    inversedBy: string;
+                };
+                segment: {
+                    type: string;
+                    relation: string;
+                    target: string;
+                };
+                priority: {
+                    type: string;
+                    default: number;
+                    min: number;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,24 @@
+declare const _default: {
+    segment: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        find(ctx: any): Promise<void>;
+        findOne(ctx: any): Promise<void>;
+        create(ctx: any): Promise<void>;
+        update(ctx: any): Promise<void>;
+        delete(ctx: any): Promise<void>;
+    };
+    'variant-link': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        find(ctx: any): Promise<void>;
+        findOne(ctx: any): Promise<void>;
+        create(ctx: any): Promise<void>;
+        update(ctx: any): Promise<void>;
+        delete(ctx: any): Promise<void>;
+        findFamily(ctx: any): Promise<void>;
+        findBatch(ctx: any): Promise<void>;
+        createWithVariant(ctx: any): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/segment.d.ts

@@ -0,0 +1,11 @@
+import type { Core } from '@strapi/strapi';
+declare const segmentController: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    find(ctx: any): Promise<void>;
+    findOne(ctx: any): Promise<void>;
+    create(ctx: any): Promise<void>;
+    update(ctx: any): Promise<void>;
+    delete(ctx: any): Promise<void>;
+};
+export default segmentController;

package/dist/server/src/controllers/variant-link.d.ts

@@ -0,0 +1,18 @@
+import type { Core } from '@strapi/strapi';
+declare const variantLinkController: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    find(ctx: any): Promise<void>;
+    findOne(ctx: any): Promise<void>;
+    create(ctx: any): Promise<void>;
+    update(ctx: any): Promise<void>;
+    delete(ctx: any): Promise<void>;
+    findFamily(ctx: any): Promise<void>;
+    findBatch(ctx: any): Promise<void>;
+    /**
+     * Clones base content document (current locale only), creates the variant document,
+     * then creates variant-link + variant-assignments for selected segments.
+     */
+    createWithVariant(ctx: any): Promise<void>;
+};
+export default variantLinkController;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,244 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: {};
+        validator(config: Record<string, unknown>): void;
+    };
+    contentTypes: {
+        segment: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {};
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    slug: {
+                        type: string;
+                        required: boolean;
+                        unique: boolean;
+                    };
+                    description: {
+                        type: string;
+                    };
+                    externalId: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        'variant-link': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    baseContentType: {
+                        type: string;
+                        required: boolean;
+                    };
+                    baseDocumentId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    variantDocumentId: {
+                        type: string;
+                        required: boolean;
+                    };
+                    label: {
+                        type: string;
+                    };
+                    assignments: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        mappedBy: string;
+                    };
+                };
+            };
+        };
+        'variant-assignment': {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    variantLink: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        inversedBy: string;
+                    };
+                    segment: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                    };
+                    priority: {
+                        type: string;
+                        default: number;
+                        min: number;
+                    };
+                };
+            };
+        };
+    };
+    controllers: {
+        segment: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find(ctx: any): Promise<void>;
+            findOne(ctx: any): Promise<void>;
+            create(ctx: any): Promise<void>;
+            update(ctx: any): Promise<void>;
+            delete(ctx: any): Promise<void>;
+        };
+        'variant-link': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find(ctx: any): Promise<void>;
+            findOne(ctx: any): Promise<void>;
+            create(ctx: any): Promise<void>;
+            update(ctx: any): Promise<void>;
+            delete(ctx: any): Promise<void>;
+            findFamily(ctx: any): Promise<void>;
+            findBatch(ctx: any): Promise<void>;
+            createWithVariant(ctx: any): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+        'content-api': {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+    };
+    services: {
+        segment: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find(query?: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+            findOne(documentId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+            create(data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+            update(documentId: string, data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+            delete(documentId: string): Promise<{
+                documentId: string;
+                entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+            }>;
+        };
+        'variant-resolver': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getVariantFieldNames(contentTypeUid: string): string[];
+            extractVariantFields(document: Record<string, any>, contentTypeUid: string): Record<string, any>;
+            resolveDocument(base: Record<string, any>, variant: Record<string, any>, options: import("./services/variant-resolver").ResolveOptions): Record<string, any>;
+        };
+        'variant-link': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            find(query?: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+            findOne(documentId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+            create(data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+            update(documentId: string, data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+            delete(documentId: string): Promise<{
+                documentId: string;
+                entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+            }>;
+            findFamily(query: {
+                contentType: string;
+                documentId: string;
+            }): Promise<{
+                baseDocumentId: string;
+                isVariant: boolean;
+                currentDocumentId: string;
+                baseStatus: string;
+                links: any[];
+            }>;
+            findVariantDocumentIds(contentType: string): Promise<Set<string>>;
+            findBatch(query: {
+                baseContentType: string;
+                documentIds: string[];
+            }): Promise<Record<string, any[]>>;
+            createWithVariant(payload: {
+                baseContentType: string;
+                baseDocumentId: string;
+                locale?: string | undefined;
+                label?: string | undefined;
+                segments: {
+                    documentId: string;
+                    name?: string | undefined;
+                }[];
+            }): Promise<{
+                variantDocumentId: string;
+                variantLinkDocumentId: string;
+            }>;
+        };
+    };
+};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Public content-API routes.
+ *
+ * Exposes a read-only segments endpoint so frontends can fetch the list
+ * of available segments (for rendering segment pickers or passing to
+ * the segment query parameter).
+ */
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+            };
+        }[];
+    };
+    'content-api': {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,62 @@
+declare const _default: {
+    segment: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        find(query?: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+        findOne(documentId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+        create(data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+        update(documentId: string, data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+        delete(documentId: string): Promise<{
+            documentId: string;
+            entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+        }>;
+    };
+    'variant-resolver': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getVariantFieldNames(contentTypeUid: string): string[];
+        extractVariantFields(document: Record<string, any>, contentTypeUid: string): Record<string, any>;
+        resolveDocument(base: Record<string, any>, variant: Record<string, any>, options: import("./variant-resolver").ResolveOptions): Record<string, any>;
+    };
+    'variant-link': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        find(query?: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+        findOne(documentId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+        create(data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+        update(documentId: string, data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+        delete(documentId: string): Promise<{
+            documentId: string;
+            entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+        }>;
+        findFamily(query: {
+            contentType: string;
+            documentId: string;
+        }): Promise<{
+            baseDocumentId: string;
+            isVariant: boolean;
+            currentDocumentId: string;
+            baseStatus: string;
+            links: any[];
+        }>;
+        findVariantDocumentIds(contentType: string): Promise<Set<string>>;
+        findBatch(query: {
+            baseContentType: string;
+            documentIds: string[];
+        }): Promise<Record<string, any[]>>;
+        createWithVariant(payload: {
+            baseContentType: string;
+            baseDocumentId: string;
+            locale?: string | undefined;
+            label?: string | undefined;
+            segments: {
+                documentId: string;
+                name?: string | undefined;
+            }[];
+        }): Promise<{
+            variantDocumentId: string;
+            variantLinkDocumentId: string;
+        }>;
+    };
+};
+export default _default;

package/dist/server/src/services/segment.d.ts

@@ -0,0 +1,14 @@
+import type { Core } from '@strapi/strapi';
+declare const segmentService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    find(query?: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+    findOne(documentId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+    create(data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+    update(documentId: string, data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+    delete(documentId: string): Promise<{
+        documentId: string;
+        entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+    }>;
+};
+export default segmentService;

package/dist/server/src/services/variant-link.d.ts

@@ -0,0 +1,60 @@
+import type { Core } from '@strapi/strapi';
+declare const variantLinkService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    find(query?: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument[]>;
+    findOne(documentId: string): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+    create(data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+    update(documentId: string, data: any): Promise<import("@strapi/types/dist/modules/documents").AnyDocument | null>;
+    delete(documentId: string): Promise<{
+        documentId: string;
+        entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+    }>;
+    /**
+     * Resolves the full "variant family" for any document (base or variant).
+     * Returns { baseDocumentId, isVariant, currentDocumentId, baseStatus, links[] }.
+     * Each link is enriched with `variantStatus` ('draft' | 'published' | 'modified').
+     */
+    findFamily(query: {
+        contentType: string;
+        documentId: string;
+    }): Promise<{
+        baseDocumentId: string;
+        isVariant: boolean;
+        currentDocumentId: string;
+        baseStatus: string;
+        links: any[];
+    }>;
+    /**
+     * Returns a Set of all variantDocumentIds for a given content type.
+     * Used to filter variant clones out of public API list results.
+     */
+    findVariantDocumentIds(contentType: string): Promise<Set<string>>;
+    /**
+     * Batch fetch variant links for multiple document IDs (base or variant).
+     * Searches both baseDocumentId and variantDocumentId fields.
+     * Returns a map of documentId → links[].
+     */
+    findBatch(query: {
+        baseContentType: string;
+        documentIds: string[];
+    }): Promise<Record<string, any[]>>;
+    /**
+     * Creates a new variant document by cloning the base document (current locale),
+     * then creates the variant-link and its variant-assignments (segments + priority).
+     */
+    createWithVariant(payload: {
+        baseContentType: string;
+        baseDocumentId: string;
+        locale?: string;
+        label?: string;
+        segments: Array<{
+            documentId: string;
+            name?: string;
+        }>;
+    }): Promise<{
+        variantDocumentId: string;
+        variantLinkDocumentId: string;
+    }>;
+};
+export default variantLinkService;

package/dist/server/src/services/variant-resolver.d.ts

@@ -0,0 +1,23 @@
+import type { Core } from '@strapi/strapi';
+export interface ResolveOptions {
+    segmentSlug: string;
+    contentTypeUid: string;
+}
+declare const variantResolverService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Returns the list of field names marked as variant on a content type.
+     */
+    getVariantFieldNames(contentTypeUid: string): string[];
+    /**
+     * Extracts only the variant-marked field values from a document.
+     */
+    extractVariantFields(document: Record<string, any>, contentTypeUid: string): Record<string, any>;
+    /**
+     * Resolve variant fields: start with base document, overlay variant-marked
+     * fields from the variant document.
+     */
+    resolveDocument(base: Record<string, any>, variant: Record<string, any>, options: ResolveOptions): Record<string, any>;
+};
+export default variantResolverService;