@zachariaz/strapi-plugin-content-variants 0.1.0

package/dist/server/index.js

@@ -0,0 +1,895 @@
+"use strict";
+const register = ({ strapi }) => {
+};
+const PLUGIN_ID$1 = "content-variants";
+const VARIANT_LINK_UID$1 = "plugin::content-variants.variant-link";
+const bootstrap = async ({ strapi }) => {
+  strapi.server.use(async (ctx, next) => {
+    const segment = ctx.query?.segment;
+    const includeVariants = ctx.query?.includeVariants;
+    if (segment) ctx.state.segment = segment;
+    if (includeVariants) ctx.state.includeVariants = includeVariants;
+    await next();
+    if (segment) {
+      ctx.set("Vary", "segment");
+      ctx.set("Cache-Control", "public, max-age=60, s-maxage=300");
+    } else if (includeVariants === "true") {
+      ctx.set("Vary", "includeVariants");
+      ctx.set("Cache-Control", "public, max-age=300, s-maxage=600");
+    }
+  });
+  strapi.documents.use(async (ctx, next) => {
+    const result = await next();
+    const action = ctx.action;
+    if (action !== "findMany" && action !== "findOne") {
+      return result;
+    }
+    const contentTypeUid = ctx.uid;
+    if (!contentTypeUid) return result;
+    if (typeof contentTypeUid === "string" && contentTypeUid.startsWith("plugin::content-variants.")) {
+      return result;
+    }
+    const params = ctx.params || {};
+    const segment = params.segment || params.filters?.segment || ctx.state?.segment;
+    const includeVariants = params.includeVariants || ctx.state?.includeVariants;
+    const isSegmentMode = typeof segment === "string" && segment.length > 0;
+    const isEnrichedMode = includeVariants === "true" && !isSegmentMode;
+    if (!isSegmentMode && !isEnrichedMode) {
+      return result;
+    }
+    const resolver = strapi.plugin(PLUGIN_ID$1).service("variant-resolver");
+    const variantLinkService2 = strapi.plugin(PLUGIN_ID$1).service("variant-link");
+    const isVariantEnabledUid = (uid) => {
+      try {
+        const ct = strapi.contentType(uid);
+        return !!ct?.pluginOptions?.[PLUGIN_ID$1]?.enabled;
+      } catch {
+        return false;
+      }
+    };
+    const topLevelVariantEnabled = isVariantEnabledUid(contentTypeUid);
+    const getVariantIds = async () => {
+      return variantLinkService2.findVariantDocumentIds(contentTypeUid);
+    };
+    const resolveDoc = async (base, targetUid) => {
+      if (!base || !base.documentId) return base;
+      const links = await strapi.documents(VARIANT_LINK_UID$1).findMany({
+        filters: {
+          $and: [
+            { baseContentType: { $eq: targetUid } },
+            { baseDocumentId: { $eq: base.documentId } }
+          ]
+        },
+        populate: ["assignments.segment"]
+      });
+      if (!Array.isArray(links) || links.length === 0) {
+        return base;
+      }
+      let bestLink = null;
+      let bestPriority = Infinity;
+      for (const link of links) {
+        for (const assignment of link.assignments || []) {
+          if (assignment.segment?.slug === segment) {
+            const p = assignment.priority ?? 0;
+            if (p < bestPriority) {
+              bestPriority = p;
+              bestLink = link;
+            }
+          }
+        }
+      }
+      if (!bestLink || !bestLink.variantDocumentId) {
+        return base;
+      }
+      const variant = await strapi.documents(targetUid).findOne({
+        documentId: bestLink.variantDocumentId,
+        ...params.locale ? { locale: params.locale } : {},
+        ...params.status ? { status: params.status } : {}
+      });
+      if (!variant) {
+        return base;
+      }
+      return resolver.resolveDocument(base, variant, {
+        segmentSlug: segment,
+        contentTypeUid: targetUid
+      });
+    };
+    const enrichDoc = async (base, targetUid) => {
+      if (!base || !base.documentId) return base;
+      const links = await strapi.documents(VARIANT_LINK_UID$1).findMany({
+        filters: {
+          $and: [
+            { baseContentType: { $eq: targetUid } },
+            { baseDocumentId: { $eq: base.documentId } }
+          ]
+        },
+        populate: ["assignments.segment"]
+      });
+      if (!Array.isArray(links) || links.length === 0) {
+        return { ...base, _variants: [] };
+      }
+      const variants = [];
+      for (const link of links) {
+        const variantDoc = await strapi.documents(targetUid).findOne({
+          documentId: link.variantDocumentId,
+          ...params.locale ? { locale: params.locale } : {},
+          ...params.status ? { status: params.status } : {}
+        });
+        if (!variantDoc) continue;
+        const fields = resolver.extractVariantFields(variantDoc, targetUid);
+        const segments = (link.assignments || []).filter((a) => a.segment).map((a) => ({
+          name: a.segment.name,
+          slug: a.segment.slug
+        }));
+        variants.push({
+          documentId: link.variantDocumentId,
+          segments,
+          fields
+        });
+      }
+      return { ...base, _variants: variants };
+    };
+    const resolvePopulated = async (doc, ownerUid) => {
+      if (!doc || typeof doc !== "object") return;
+      let contentType;
+      try {
+        contentType = strapi.contentType(ownerUid);
+      } catch {
+        return;
+      }
+      const attributes2 = contentType?.attributes || {};
+      for (const [fieldName, attr] of Object.entries(attributes2)) {
+        const attribute = attr;
+        if (attribute.type === "relation" && attribute.target) {
+          const populated = doc[fieldName];
+          if (!populated || typeof populated !== "object") continue;
+          const targetUid = attribute.target;
+          if (targetUid.startsWith("plugin::content-variants.")) continue;
+          const targetVariantEnabled = isVariantEnabledUid(targetUid);
+          const isArray = Array.isArray(populated);
+          const items = isArray ? populated : [populated];
+          const processed = [];
+          for (const item of items) {
+            let resolved = item;
+            if (targetVariantEnabled && item?.documentId) {
+              if (isSegmentMode) {
+                resolved = await resolveDoc(item, targetUid);
+              } else if (isEnrichedMode) {
+                resolved = await enrichDoc(item, targetUid);
+              }
+            }
+            await resolvePopulated(resolved, targetUid);
+            processed.push(resolved);
+          }
+          doc[fieldName] = isArray ? processed : processed[0];
+          continue;
+        }
+        if (attribute.type === "component" && attribute.component) {
+          const populated = doc[fieldName];
+          if (!populated) continue;
+          const componentUid = attribute.component;
+          if (attribute.repeatable && Array.isArray(populated)) {
+            for (const item of populated) {
+              await resolvePopulated(item, componentUid);
+            }
+          } else if (typeof populated === "object") {
+            await resolvePopulated(populated, componentUid);
+          }
+          continue;
+        }
+        if (attribute.type === "dynamiczone") {
+          const populated = doc[fieldName];
+          if (!Array.isArray(populated)) continue;
+          for (const item of populated) {
+            if (item?.__component) {
+              await resolvePopulated(item, item.__component);
+            }
+          }
+        }
+      }
+    };
+    const filterVariants = async (docs) => {
+      const variantIds = await getVariantIds();
+      if (variantIds.size === 0) return docs;
+      return docs.filter((doc) => !variantIds.has(doc.documentId));
+    };
+    const processDocArray = async (docs) => {
+      const filtered = topLevelVariantEnabled ? await filterVariants(docs) : docs;
+      const processed = [];
+      for (const item of filtered) {
+        let doc = item;
+        if (topLevelVariantEnabled) {
+          if (isSegmentMode) {
+            doc = await resolveDoc(item, contentTypeUid);
+          } else if (isEnrichedMode) {
+            doc = await enrichDoc(item, contentTypeUid);
+          }
+        }
+        await resolvePopulated(doc, contentTypeUid);
+        processed.push(doc);
+      }
+      return processed;
+    };
+    if (action === "findOne" && result && typeof result === "object" && !Array.isArray(result)) {
+      let doc = result;
+      if (topLevelVariantEnabled) {
+        if (isSegmentMode) {
+          doc = await resolveDoc(result, contentTypeUid);
+        } else if (isEnrichedMode) {
+          doc = await enrichDoc(result, contentTypeUid);
+        }
+      }
+      await resolvePopulated(doc, contentTypeUid);
+      return doc;
+    }
+    if (action === "findMany") {
+      if (Array.isArray(result)) {
+        return processDocArray(result);
+      }
+      const resultObj = result;
+      if (resultObj?.results && Array.isArray(resultObj.results)) {
+        return {
+          ...resultObj,
+          results: await processDocArray(resultObj.results)
+        };
+      }
+    }
+    return result;
+  });
+};
+const destroy = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator(config2) {
+  }
+};
+const kind$2 = "collectionType";
+const collectionName$2 = "segments";
+const info$2 = {
+  singularName: "segment",
+  pluralName: "segments",
+  displayName: "Segment"
+};
+const options$2 = {
+  draftAndPublish: false
+};
+const pluginOptions$2 = {};
+const attributes$2 = {
+  name: {
+    type: "string",
+    required: true,
+    unique: true
+  },
+  slug: {
+    type: "string",
+    required: true,
+    unique: true
+  },
+  description: {
+    type: "text"
+  },
+  externalId: {
+    type: "string"
+  }
+};
+const segmentSchema = {
+  kind: kind$2,
+  collectionName: collectionName$2,
+  info: info$2,
+  options: options$2,
+  pluginOptions: pluginOptions$2,
+  attributes: attributes$2
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "content_variant_links";
+const info$1 = {
+  singularName: "variant-link",
+  pluralName: "variant-links",
+  displayName: "Variant Link"
+};
+const options$1 = {
+  draftAndPublish: false
+};
+const pluginOptions$1 = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes$1 = {
+  baseContentType: {
+    type: "string",
+    required: true
+  },
+  baseDocumentId: {
+    type: "string",
+    required: true
+  },
+  variantDocumentId: {
+    type: "string",
+    required: true
+  },
+  label: {
+    type: "string"
+  },
+  assignments: {
+    type: "relation",
+    relation: "oneToMany",
+    target: "plugin::content-variants.variant-assignment",
+    mappedBy: "variantLink"
+  }
+};
+const variantLinkSchema = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const kind = "collectionType";
+const collectionName = "content_variant_assignments";
+const info = {
+  singularName: "variant-assignment",
+  pluralName: "variant-assignments",
+  displayName: "Variant Assignment"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  variantLink: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::content-variants.variant-link",
+    inversedBy: "assignments"
+  },
+  segment: {
+    type: "relation",
+    relation: "oneToOne",
+    target: "plugin::content-variants.segment"
+  },
+  priority: {
+    type: "integer",
+    "default": 0,
+    min: 0
+  }
+};
+const variantAssignmentSchema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  segment: { schema: segmentSchema },
+  "variant-link": { schema: variantLinkSchema },
+  "variant-assignment": { schema: variantAssignmentSchema }
+};
+const segmentController = ({ strapi }) => ({
+  async find(ctx) {
+    const entities = await strapi.plugin("content-variants").service("segment").find(ctx.query);
+    ctx.body = entities;
+  },
+  async findOne(ctx) {
+    const { id } = ctx.params;
+    const entity = await strapi.plugin("content-variants").service("segment").findOne(id);
+    ctx.body = entity;
+  },
+  async create(ctx) {
+    const entity = await strapi.plugin("content-variants").service("segment").create(ctx.request.body);
+    ctx.body = entity;
+  },
+  async update(ctx) {
+    const { id } = ctx.params;
+    const entity = await strapi.plugin("content-variants").service("segment").update(id, ctx.request.body);
+    ctx.body = entity;
+  },
+  async delete(ctx) {
+    const { id } = ctx.params;
+    const entity = await strapi.plugin("content-variants").service("segment").delete(id);
+    ctx.body = entity;
+  }
+});
+const variantLinkController = ({ strapi }) => ({
+  async find(ctx) {
+    const entities = await strapi.plugin("content-variants").service("variant-link").find(ctx.query);
+    ctx.body = entities;
+  },
+  async findOne(ctx) {
+    const { id } = ctx.params;
+    const entity = await strapi.plugin("content-variants").service("variant-link").findOne(id);
+    ctx.body = entity;
+  },
+  async create(ctx) {
+    const entity = await strapi.plugin("content-variants").service("variant-link").create(ctx.request.body);
+    ctx.body = entity;
+  },
+  async update(ctx) {
+    const { id } = ctx.params;
+    const entity = await strapi.plugin("content-variants").service("variant-link").update(id, ctx.request.body);
+    ctx.body = entity;
+  },
+  async delete(ctx) {
+    const { id } = ctx.params;
+    const entity = await strapi.plugin("content-variants").service("variant-link").delete(id);
+    ctx.body = entity;
+  },
+  async findFamily(ctx) {
+    const entity = await strapi.plugin("content-variants").service("variant-link").findFamily(ctx.query);
+    ctx.body = entity;
+  },
+  async findBatch(ctx) {
+    const entity = await strapi.plugin("content-variants").service("variant-link").findBatch(ctx.request.body);
+    ctx.body = entity;
+  },
+  /**
+   * Clones base content document (current locale only), creates the variant document,
+   * then creates variant-link + variant-assignments for selected segments.
+   */
+  async createWithVariant(ctx) {
+    const entity = await strapi.plugin("content-variants").service("variant-link").createWithVariant(ctx.request.body);
+    ctx.body = entity;
+  }
+});
+const controllers = {
+  segment: segmentController,
+  "variant-link": variantLinkController
+};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/segments",
+      handler: "segment.find",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/segments/:id",
+      handler: "segment.findOne",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/segments",
+      handler: "segment.create",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/segments/:id",
+      handler: "segment.update",
+      config: { policies: [] }
+    },
+    {
+      method: "DELETE",
+      path: "/segments/:id",
+      handler: "segment.delete",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/links/family",
+      handler: "variant-link.findFamily",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/links/batch",
+      handler: "variant-link.findBatch",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/links/with-variant",
+      handler: "variant-link.createWithVariant",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/links",
+      handler: "variant-link.find",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/links/:id",
+      handler: "variant-link.findOne",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/links",
+      handler: "variant-link.create",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/links/:id",
+      handler: "variant-link.update",
+      config: { policies: [] }
+    },
+    {
+      method: "DELETE",
+      path: "/links/:id",
+      handler: "variant-link.delete",
+      config: { policies: [] }
+    }
+  ]
+};
+const contentApi = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/segments",
+      handler: "segment.find",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  admin,
+  "content-api": contentApi
+};
+const UID = "plugin::content-variants.segment";
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-");
+}
+const segmentService = ({ strapi }) => ({
+  async find(query = {}) {
+    return strapi.documents(UID).findMany(query);
+  },
+  async findOne(documentId) {
+    return strapi.documents(UID).findOne({ documentId });
+  },
+  async create(data) {
+    if (!data.slug && data.name) {
+      data.slug = slugify(data.name);
+    }
+    return strapi.documents(UID).create({ data });
+  },
+  async update(documentId, data) {
+    return strapi.documents(UID).update({ documentId, data });
+  },
+  async delete(documentId) {
+    return strapi.documents(UID).delete({ documentId });
+  }
+});
+const PLUGIN_ID = "content-variants";
+const variantResolverService = ({ strapi }) => ({
+  /**
+   * Returns the list of field names marked as variant on a content type.
+   */
+  getVariantFieldNames(contentTypeUid) {
+    const contentType = strapi.contentType(contentTypeUid);
+    if (!contentType) return [];
+    const attributes2 = contentType.attributes || {};
+    const names = [];
+    for (const [fieldName, attr] of Object.entries(attributes2)) {
+      const attribute = attr;
+      if (attribute?.pluginOptions?.[PLUGIN_ID]?.variant) {
+        names.push(fieldName);
+      }
+    }
+    return names;
+  },
+  /**
+   * Extracts only the variant-marked field values from a document.
+   */
+  extractVariantFields(document, contentTypeUid) {
+    const fieldNames = this.getVariantFieldNames(contentTypeUid);
+    const fields = {};
+    for (const name of fieldNames) {
+      if (name in document) {
+        fields[name] = document[name];
+      }
+    }
+    return fields;
+  },
+  /**
+   * Resolve variant fields: start with base document, overlay variant-marked
+   * fields from the variant document.
+   */
+  resolveDocument(base, variant, options2) {
+    if (!base) return base;
+    if (!variant) return base;
+    const contentType = strapi.contentType(options2.contentTypeUid);
+    if (!contentType) return base;
+    const ctOptions = contentType.pluginOptions;
+    if (!ctOptions?.[PLUGIN_ID]?.enabled) return base;
+    const resolved = { ...base };
+    const fieldNames = this.getVariantFieldNames(options2.contentTypeUid);
+    for (const fieldName of fieldNames) {
+      if (fieldName in variant) {
+        resolved[fieldName] = variant[fieldName];
+      }
+    }
+    return resolved;
+  }
+});
+const VARIANT_LINK_UID = "plugin::content-variants.variant-link";
+const VARIANT_ASSIGNMENT_UID = "plugin::content-variants.variant-assignment";
+const variantLinkService = ({ strapi }) => ({
+  async find(query = {}) {
+    const { baseContentType, baseDocumentId, variantDocumentId, populate, ...rest } = query;
+    const conditions = [];
+    if (baseContentType) {
+      conditions.push({ baseContentType: { $eq: baseContentType } });
+    }
+    if (baseDocumentId) {
+      conditions.push({ baseDocumentId: { $eq: baseDocumentId } });
+    }
+    if (variantDocumentId) {
+      conditions.push({ variantDocumentId: { $eq: variantDocumentId } });
+    }
+    return strapi.documents(VARIANT_LINK_UID).findMany({
+      ...rest,
+      filters: conditions.length > 0 ? { $and: conditions } : void 0,
+      populate: populate || ["assignments.segment"]
+    });
+  },
+  async findOne(documentId) {
+    return strapi.documents(VARIANT_LINK_UID).findOne({
+      documentId,
+      populate: ["assignments.segment"]
+    });
+  },
+  async create(data) {
+    return strapi.documents(VARIANT_LINK_UID).create({ data });
+  },
+  async update(documentId, data) {
+    return strapi.documents(VARIANT_LINK_UID).update({ documentId, data });
+  },
+  async delete(documentId) {
+    const link = await strapi.documents(VARIANT_LINK_UID).findOne({
+      documentId
+    });
+    const result = await strapi.documents(VARIANT_LINK_UID).delete({ documentId });
+    if (link?.variantDocumentId && link?.baseContentType) {
+      try {
+        await strapi.documents(link.baseContentType).delete({
+          documentId: link.variantDocumentId
+        });
+      } catch {
+      }
+    }
+    return result;
+  },
+  /**
+   * 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').
+   */
+  async findFamily(query) {
+    const { contentType, documentId } = query;
+    if (!contentType || !documentId) {
+      throw new Error("contentType and documentId are required");
+    }
+    const asVariant = await strapi.documents(VARIANT_LINK_UID).findMany({
+      filters: {
+        $and: [
+          { baseContentType: { $eq: contentType } },
+          { variantDocumentId: { $eq: documentId } }
+        ]
+      },
+      populate: ["assignments.segment"]
+    });
+    let baseDocumentId;
+    let isVariant;
+    if (asVariant.length > 0) {
+      baseDocumentId = asVariant[0].baseDocumentId;
+      isVariant = true;
+    } else {
+      baseDocumentId = documentId;
+      isVariant = false;
+    }
+    const links = await strapi.documents(VARIANT_LINK_UID).findMany({
+      filters: {
+        $and: [
+          { baseContentType: { $eq: contentType } },
+          { baseDocumentId: { $eq: baseDocumentId } }
+        ]
+      },
+      populate: ["assignments.segment"]
+    });
+    const resolveStatus = async (docId) => {
+      try {
+        const published = await strapi.documents(contentType).findOne({
+          documentId: docId,
+          status: "published"
+        });
+        if (!published) return "draft";
+        const draft = await strapi.documents(contentType).findOne({
+          documentId: docId
+        });
+        if (draft && new Date(draft.updatedAt) > new Date(published.updatedAt)) {
+          return "modified";
+        }
+        return "published";
+      } catch {
+        return "draft";
+      }
+    };
+    const allDocIds = [baseDocumentId, ...links.map((l) => l.variantDocumentId)].filter(Boolean);
+    const statuses = await Promise.all(allDocIds.map(resolveStatus));
+    const statusMap = {};
+    allDocIds.forEach((id, i) => {
+      statusMap[id] = statuses[i];
+    });
+    const enrichedLinks = links.map((link) => ({
+      ...link,
+      variantStatus: statusMap[link.variantDocumentId] || "draft"
+    }));
+    return {
+      baseDocumentId,
+      isVariant,
+      currentDocumentId: documentId,
+      baseStatus: statusMap[baseDocumentId] || "draft",
+      links: enrichedLinks
+    };
+  },
+  /**
+   * Returns a Set of all variantDocumentIds for a given content type.
+   * Used to filter variant clones out of public API list results.
+   */
+  async findVariantDocumentIds(contentType) {
+    const links = await strapi.documents(VARIANT_LINK_UID).findMany({
+      filters: { baseContentType: { $eq: contentType } },
+      fields: ["variantDocumentId"]
+    });
+    return new Set(links.map((l) => l.variantDocumentId));
+  },
+  /**
+   * Batch fetch variant links for multiple document IDs (base or variant).
+   * Searches both baseDocumentId and variantDocumentId fields.
+   * Returns a map of documentId → links[].
+   */
+  async findBatch(query) {
+    const { baseContentType, documentIds } = query;
+    if (!baseContentType || !Array.isArray(documentIds) || documentIds.length === 0) {
+      return {};
+    }
+    const links = await strapi.documents(VARIANT_LINK_UID).findMany({
+      filters: {
+        $and: [
+          { baseContentType: { $eq: baseContentType } },
+          {
+            $or: [
+              { baseDocumentId: { $in: documentIds } },
+              { variantDocumentId: { $in: documentIds } }
+            ]
+          }
+        ]
+      },
+      populate: ["assignments.segment"]
+    });
+    const grouped = {};
+    for (const id of documentIds) {
+      grouped[id] = [];
+    }
+    const idSet = new Set(documentIds);
+    for (const link of links) {
+      if (idSet.has(link.baseDocumentId)) {
+        grouped[link.baseDocumentId].push(link);
+      }
+      if (idSet.has(link.variantDocumentId)) {
+        grouped[link.variantDocumentId].push(link);
+      }
+    }
+    return grouped;
+  },
+  /**
+   * Creates a new variant document by cloning the base document (current locale),
+   * then creates the variant-link and its variant-assignments (segments + priority).
+   */
+  async createWithVariant(payload) {
+    const { baseContentType, baseDocumentId, locale, label, segments } = payload || {};
+    if (!baseContentType || !baseDocumentId) {
+      throw new Error("baseContentType and baseDocumentId are required");
+    }
+    if (!Array.isArray(segments) || segments.length === 0) {
+      throw new Error("segments[] is required");
+    }
+    const existingLinks = await strapi.documents(VARIANT_LINK_UID).findMany({
+      filters: {
+        $and: [
+          { baseContentType: { $eq: baseContentType } },
+          { baseDocumentId: { $eq: baseDocumentId } }
+        ]
+      },
+      populate: ["assignments.segment"]
+    });
+    const assignedSegmentIds = /* @__PURE__ */ new Set();
+    for (const link of existingLinks) {
+      for (const assignment of link.assignments || []) {
+        if (assignment.segment?.documentId) {
+          assignedSegmentIds.add(assignment.segment.documentId);
+        }
+      }
+    }
+    const duplicateSegments = segments.filter((s) => assignedSegmentIds.has(s.documentId));
+    if (duplicateSegments.length > 0) {
+      const names = duplicateSegments.map((s) => s.name || s.documentId).join(", ");
+      throw new Error(`Segments already assigned to existing variants: ${names}`);
+    }
+    const base = await strapi.documents(baseContentType).findOne({
+      documentId: baseDocumentId,
+      ...locale ? { locale } : {}
+    });
+    const contentType = strapi.contentType(baseContentType);
+    const attributes2 = contentType?.attributes || {};
+    const clonedData = {};
+    for (const attrKey of Object.keys(attributes2)) {
+      if (Object.prototype.hasOwnProperty.call(base, attrKey) && typeof base[attrKey] !== "undefined") {
+        clonedData[attrKey] = base[attrKey];
+      }
+    }
+    const variant = await strapi.documents(baseContentType).create({
+      data: clonedData
+    });
+    const variantDocumentId = variant?.documentId;
+    if (!variantDocumentId) {
+      throw new Error("Variant documentId was not returned");
+    }
+    const segmentNames = segments.map((s) => s.name).filter(Boolean);
+    const computedLabel = label?.trim() || (segmentNames.length > 0 ? `Variant for ${segmentNames.join(", ")}` : "Variant");
+    const variantLink = await strapi.documents(VARIANT_LINK_UID).create({
+      data: {
+        baseContentType,
+        baseDocumentId,
+        variantDocumentId,
+        label: computedLabel
+      }
+    });
+    const variantLinkDocumentId = variantLink?.documentId;
+    if (!variantLinkDocumentId) {
+      throw new Error("variant-link documentId was not returned");
+    }
+    await Promise.all(
+      segments.map(
+        (seg) => strapi.documents(VARIANT_ASSIGNMENT_UID).create({
+          data: {
+            priority: 0,
+            variantLink: { documentId: variantLinkDocumentId },
+            segment: { documentId: seg.documentId }
+          }
+        })
+      )
+    );
+    return { variantDocumentId, variantLinkDocumentId };
+  }
+});
+const services = {
+  segment: segmentService,
+  "variant-resolver": variantResolverService,
+  "variant-link": variantLinkService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  contentTypes,
+  controllers,
+  routes,
+  services
+};
+module.exports = index;