@bluedynamics/cdk8s-plone 0.1.22 → 0.1.24

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { Plone, PloneOptions, PloneBaseOptions, PloneVariant } from './plone';
 export { PloneHttpcache, PloneHttpcacheOptions, HttpcacheEnvVar, HttpcacheToleration } from './httpcache';
+export { PloneVinylCache, PloneVinylCacheOptions, VinylCacheToleration } from './vinylcache';

package/lib/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PloneHttpcache = exports.PloneVariant = exports.Plone = void 0;
+exports.PloneVinylCache = exports.PloneHttpcache = exports.PloneVariant = exports.Plone = void 0;
 var plone_1 = require("./plone");
 Object.defineProperty(exports, "Plone", { enumerable: true, get: function () { return plone_1.Plone; } });
 Object.defineProperty(exports, "PloneVariant", { enumerable: true, get: function () { return plone_1.PloneVariant; } });
 var httpcache_1 = require("./httpcache");
 Object.defineProperty(exports, "PloneHttpcache", { enumerable: true, get: function () { return httpcache_1.PloneHttpcache; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsaUNBQThFO0FBQXJFLDhGQUFBLEtBQUssT0FBQTtBQUFrQyxxR0FBQSxZQUFZLE9BQUE7QUFDNUQseUNBQTBHO0FBQWpHLDJHQUFBLGNBQWMsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFBsb25lLCBQbG9uZU9wdGlvbnMsIFBsb25lQmFzZU9wdGlvbnMsIFBsb25lVmFyaWFudCB9IGZyb20gJy4vcGxvbmUnO1xuZXhwb3J0IHsgUGxvbmVIdHRwY2FjaGUsIFBsb25lSHR0cGNhY2hlT3B0aW9ucywgSHR0cGNhY2hlRW52VmFyLCBIdHRwY2FjaGVUb2xlcmF0aW9uIH0gZnJvbSAnLi9odHRwY2FjaGUnO1xuIl19
+var vinylcache_1 = require("./vinylcache");
+Object.defineProperty(exports, "PloneVinylCache", { enumerable: true, get: function () { return vinylcache_1.PloneVinylCache; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsaUNBQThFO0FBQXJFLDhGQUFBLEtBQUssT0FBQTtBQUFrQyxxR0FBQSxZQUFZLE9BQUE7QUFDNUQseUNBQTBHO0FBQWpHLDJHQUFBLGNBQWMsT0FBQTtBQUN2QiwyQ0FBNkY7QUFBcEYsNkdBQUEsZUFBZSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgUGxvbmUsIFBsb25lT3B0aW9ucywgUGxvbmVCYXNlT3B0aW9ucywgUGxvbmVWYXJpYW50IH0gZnJvbSAnLi9wbG9uZSc7XG5leHBvcnQgeyBQbG9uZUh0dHBjYWNoZSwgUGxvbmVIdHRwY2FjaGVPcHRpb25zLCBIdHRwY2FjaGVFbnZWYXIsIEh0dHBjYWNoZVRvbGVyYXRpb24gfSBmcm9tICcuL2h0dHBjYWNoZSc7XG5leHBvcnQgeyBQbG9uZVZpbnlsQ2FjaGUsIFBsb25lVmlueWxDYWNoZU9wdGlvbnMsIFZpbnlsQ2FjaGVUb2xlcmF0aW9uIH0gZnJvbSAnLi92aW55bGNhY2hlJztcbiJdfQ==

package/lib/plone.js

@@ -258,5 +258,5 @@ class Plone extends constructs_1.Construct {
 }
 exports.Plone = Plone;
 _a = JSII_RTTI_SYMBOL_1;
-Plone[_a] = { fqn: "@bluedynamics/cdk8s-plone.Plone", version: "0.1.22" };
+Plone[_a] = { fqn: "@bluedynamics/cdk8s-plone.Plone", version: "0.1.24" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plone.js","sourceRoot":"","sources":["../src/plone.ts"],"names":[],"mappings":";;;;;AAAA,iCAA8B;AAC9B,uCAAuC;AACvC,2CAAuC;AACvC,6CAAuE;AACvE,uCAA4C;AAE5C,2EAAwG;AACxG,uCAAyC;AAsMzC;;GAEG;AACH,IAAY,YAYX;AAZD,WAAY,YAAY;IACtB;;;OAGG;IACH,+BAAe,CAAA;IAEf;;;OAGG;IACH,uCAAuB,CAAA;AACzB,CAAC,EAZW,YAAY,4BAAZ,YAAY,QAYvB;AAgDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAa,KAAM,SAAQ,sBAAS;IAuBlC,YAAY,KAAgB,EAAE,EAAU,EAAE,UAAwB,EAAE;QAClE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC;QACrC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC;QACxC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC;QAErD,2EAA2E;QAC3E,UAAU;QACV,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;QACtC,MAAM,aAAa,GAAG;YACpB,wBAAwB,EAAE,eAAe;YACzC,6BAA6B,EAAE,SAAS;YACxC,2BAA2B,EAAE,OAAO,CAAC,OAAO,IAAI,WAAW;SAC5D,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,CAAC;QAEzB,UAAU;QACV,IAAI,cAAc,GAA2B;YAC3C,MAAM,EAAE,aAAa;YACrB,KAAK,EAAE;gBACL,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,4BAA4B;gBACpD,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,EAAE;gBAChD,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,cAAc;aAC3D;YACD,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,MAAM;YACpC,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,OAAO;YAC3C,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,MAAM;YACxC,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,OAAO;YAC/C,GAAG,EAAE;gBACH,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,SAAS;gBACnD,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,SAAS;aAChD;YACD,IAAI,EAAE,WAAW;YACjB,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC;QAEF,UAAU;QACV,MAAM,oBAAoB,GAAsB;YAC9C,IAAI,EAAE,GAAG;YACT,IAAI,EAAE,iBAAW,CAAC,UAAU,CAAC,WAAW,CAAC;SAC1C,CAAC;QACF,IAAI,OAAO,CAAC,eAAe,IAAI,KAAK,EAAE,CAAC;YACrC,cAAc,CAAC,aAAa,GAAG;gBAC7B,OAAO,EAAE,oBAAoB;gBAC7B,mBAAmB,EAAE,OAAO,CAAC,2BAA2B,IAAI,EAAE;gBAC9D,cAAc,EAAE,OAAO,CAAC,sBAAsB,IAAI,CAAC;gBACnD,aAAa,EAAE,OAAO,CAAC,qBAAqB,IAAI,EAAE;gBAClD,gBAAgB,EAAE,OAAO,CAAC,wBAAwB,IAAI,CAAC;gBACvD,gBAAgB,EAAE,OAAO,CAAC,wBAAwB,IAAI,CAAC;aACxD,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,gBAAgB,IAAI,IAAI,EAAE,CAAC;YACrC,cAAc,CAAC,cAAc,GAAG;gBAC9B,OAAO,EAAE,oBAAoB;gBAC7B,mBAAmB,EAAE,OAAO,CAAC,4BAA4B,IAAI,EAAE;gBAC/D,cAAc,EAAE,OAAO,CAAC,uBAAuB,IAAI,EAAE;gBACrD,aAAa,EAAE,OAAO,CAAC,sBAAsB,IAAI,EAAE;gBACnD,gBAAgB,EAAE,OAAO,CAAC,yBAAyB,IAAI,CAAC;gBACxD,gBAAgB,EAAE,OAAO,CAAC,yBAAyB,IAAI,CAAC;aACzD,CAAC;QACJ,CAAC;QACD,aAAa;QACb,IAAI,iBAAiB,GAAG,IAAI,4BAAe,CAAC,IAAI,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QAE7E,UAAU;QACV,MAAM,cAAc,GAAG,IAAI,sBAAY,CAAC,iBAAiB,EAAE,SAAS,EAAE;YACpE,MAAM,EAAE;gBACN,wBAAwB,EAAE,uBAAuB;gBACjD,6BAA6B,EAAE,SAAS;aACzC;YACD,UAAU,EAAE,WAAW;YACvB,aAAa,EAAE,EAAE,GAAG,EAAE,aAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,EAAE;YAC7D,QAAQ,EAAE,cAAc;YACxB,WAAW,EAAE,OAAO,CAAC,kBAAkB;SACxC,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,GAAG,cAAc,CAAC,IAAI,CAAC;QAE9C,6BAA6B;QAC7B,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;YAC3B,IAAI,CAAC,oBAAoB,CAAC,cAAc,EAAE,SAAS,EAAE;gBACnD,IAAI,EAAE,OAAO,CAAC,WAAW,IAAI,cAAc;gBAC3C,IAAI,EAAE,OAAO,CAAC,WAAW,IAAI,UAAU;aACxC,CAAC,CAAC;QACL,CAAC;QAED,2EAA2E;QAC3E,WAAW;QACX,IAAI,IAAI,CAAC,OAAO,IAAI,YAAY,CAAC,KAAK,EAAE,CAAC;YACvC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC;YACxC,MAAM,YAAY,GAAG,IAAI,CAAC;YAC1B,MAAM,cAAc,GAAG;gBACrB,wBAAwB,EAAE,gBAAgB;gBAC1C,6BAA6B,EAAE,UAAU;gBACzC,2BAA2B,EAAE,OAAO,CAAC,OAAO,IAAI,WAAW;aAC5D,CAAC;YAEF,yBAAyB;YACzB,IAAI,mBAAmB,GAAG,QAAQ,CAAC,WAAW,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACxE,IAAI,mBAAmB,CAAC,SAAS,CAAC,wBAAwB,KAAK,SAAS,EAAE,CAAC;gBACzE,+BAA+B;gBAC/B,mBAAmB,EAAE,WAAW,CAAC,0BAA0B,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,cAAc,CAAC,IAAI,IAAI,WAAW,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACxJ,CAAC;YAED,UAAU;YACV,IAAI,eAAe,GAA2B;gBAC5C,MAAM,EAAE,cAAc;gBACtB,KAAK,EAAE;oBACL,KAAK,EAAE,QAAQ,CAAC,KAAK,IAAI,6BAA6B;oBACtD,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,EAAE;oBAChD,eAAe,EAAE,QAAQ,CAAC,eAAe,IAAI,cAAc;iBAC5D;gBACD,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,MAAM;gBACrC,WAAW,EAAE,QAAQ,CAAC,WAAW,IAAI,KAAK;gBAC1C,UAAU,EAAE,QAAQ,CAAC,UAAU,IAAI,MAAM;gBACzC,aAAa,EAAE,QAAQ,CAAC,aAAa,IAAI,OAAO;gBAEhD,GAAG,EAAE;oBACH,cAAc,EAAE,QAAQ,CAAC,cAAc,IAAI,SAAS;oBACpD,YAAY,EAAE,QAAQ,CAAC,YAAY,IAAI,SAAS;iBACjD;gBACD,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,mBAAmB;gBAChC,WAAW,EAAE,QAAQ,CAAC,WAAW;gBACjC,cAAc,EAAE,QAAQ,CAAC,cAAc;aACxC,CAAC;YAEF,UAAU;YACV,MAAM,qBAAqB,GAAsB;gBAC/C,IAAI,EAAE,GAAG;gBACT,IAAI,EAAE,iBAAW,CAAC,UAAU,CAAC,YAAY,CAAC;aAC3C,CAAC;YACF,IAAI,QAAQ,CAAC,eAAe,IAAI,KAAK,EAAE,CAAC;gBACtC,eAAe,CAAC,aAAa,GAAG;oBAC9B,OAAO,EAAE,qBAAqB;oBAC9B,mBAAmB,EAAE,QAAQ,CAAC,2BAA2B,IAAI,EAAE;oBAC/D,cAAc,EAAE,QAAQ,CAAC,sBAAsB,IAAI,CAAC;oBACpD,aAAa,EAAE,QAAQ,CAAC,qBAAqB,IAAI,EAAE;oBACnD,gBAAgB,EAAE,QAAQ,CAAC,wBAAwB,IAAI,CAAC;oBACxD,gBAAgB,EAAE,QAAQ,CAAC,wBAAwB,IAAI,CAAC;iBACzD,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,CAAC,gBAAgB,IAAI,IAAI,EAAE,CAAC;gBACtC,eAAe,CAAC,cAAc,GAAG;oBAC/B,OAAO,EAAE,qBAAqB;oBAC9B,mBAAmB,EAAE,QAAQ,CAAC,4BAA4B,IAAI,EAAE;oBAChE,cAAc,EAAE,QAAQ,CAAC,uBAAuB,IAAI,EAAE;oBACtD,aAAa,EAAE,QAAQ,CAAC,sBAAsB,IAAI,EAAE;oBACpD,gBAAgB,EAAE,QAAQ,CAAC,yBAAyB,IAAI,CAAC;oBACzD,gBAAgB,EAAE,QAAQ,CAAC,yBAAyB,IAAI,CAAC;iBAC1D,CAAC;YACJ,CAAC;YAED,aAAa;YACb,MAAM,kBAAkB,GAAG,IAAI,4BAAe,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;YAElF,UAAU;YACV,MAAM,eAAe,GAAG,IAAI,sBAAY,CAAC,kBAAkB,EAAE,SAAS,EAAE;gBACtE,MAAM,EAAE;oBACN,wBAAwB,EAAE,wBAAwB;oBAClD,6BAA6B,EAAE,SAAS;iBACzC;gBACD,UAAU,EAAE,YAAY;gBACxB,aAAa,EAAE,EAAE,GAAG,EAAE,aAAK,CAAC,YAAY,CAAC,kBAAkB,CAAC,EAAE;gBAC9D,QAAQ,EAAE,eAAe;gBACzB,WAAW,EAAE,QAAQ,CAAC,kBAAkB;aACzC,CAAC,CAAC;YACH,IAAI,CAAC,mBAAmB,GAAG,eAAe,CAAC,IAAI,CAAC;YAEhD,8BAA8B;YAC9B,IAAI,QAAQ,CAAC,cAAc,EAAE,CAAC;gBAC5B,IAAI,CAAC,oBAAoB,CAAC,eAAe,EAAE,UAAU,EAAE;oBACrD,IAAI,EAAE,QAAQ,CAAC,WAAW,IAAI,eAAe;oBAC7C,IAAI,EAAE,QAAQ,CAAC,WAAW,IAAI,UAAU;iBACzC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,oBAAoB,CAC1B,OAAqB,EACrB,EAAU,EACV,MAA+C;QAE/C,MAAM,QAAQ,GAAG,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QAC3E,MAAM,UAAU,GAAG,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ;YAChD,CAAC,CAAC,6DAAqC,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC;YAC/D,CAAC,CAAC,SAAS,CAAC;QAEd,IAAI,sCAAc,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE;YAC/C,QAAQ,EAAE;gBACR,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,UAAU;gBAC/B,MAAM,EAAE;oBACN,wBAAwB,EAAE,OAAO,CAAC,IAAI;oBACtC,6BAA6B,EAAE,gBAAgB;iBAChD;aACF;YACD,IAAI,EAAE;gBACJ,QAAQ,EAAE;oBACR,WAAW,EAAE;wBACX,wBAAwB,EAAE,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAAC;qBACnE;iBACF;gBACD,SAAS,EAAE;oBACT;wBACE,GAAG,CAAC,QAAQ,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;wBACnC,GAAG,CAAC,UAAU,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;wBAC7C,IAAI,EAAE,MAAM,CAAC,IAAI;wBACjB,QAAQ,EAAE,KAAK;qBAChB;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;;AArPH,sBAsPC","sourcesContent":["import { Names } from 'cdk8s';\nimport * as kplus from 'cdk8s-plus-30';\nimport { Construct } from 'constructs';\nimport { PloneDeployment, PloneDeploymentOptions } from './deployment';\nimport { IntOrString } from './imports/k8s';\nimport * as k8s from './imports/k8s';\nimport { ServiceMonitor, ServiceMonitorSpecEndpointsTargetPort } from './imports/monitoring.coreos.com';\nimport { PloneService } from './service';\n\n/**\n * Base options for Plone backend or frontend configuration.\n * These options control container image, replica count, resource limits,\n * environment variables, and health probes.\n */\nexport interface PloneBaseOptions {\n  /**\n   * Container image to use for the deployment.\n   * @example 'plone/plone-backend:6.0.10' or 'plone/plone-frontend:16.0.0'\n   * @default - 'plone/plone-backend:latest' for backend, 'plone/plone-frontend:latest' for frontend\n   */\n  readonly image?: string;\n\n  /**\n   * Image pull policy for the container.\n   * @default 'IfNotPresent'\n   */\n  readonly imagePullPolicy?: string;\n\n  /**\n   * Number of pod replicas to run.\n   * @default 2\n   */\n  readonly replicas?: number;\n\n  /**\n   * Maximum number of pods that can be unavailable during updates.\n   * Can be an absolute number (e.g., 1) or a percentage (e.g., '50%').\n   * Used in PodDisruptionBudget if specified.\n   * @default - undefined (not set)\n   */\n  readonly maxUnavailable?: number | string;\n\n  /**\n   * Minimum number of pods that must be available during updates.\n   * Can be an absolute number (e.g., 1) or a percentage (e.g., '50%').\n   * Used in PodDisruptionBudget if specified.\n   * @default - undefined (not set)\n   */\n  readonly minAvailable?: number | string;\n\n  /**\n   * CPU limit for the container.\n   * @example '500m' or '1' or '2000m'\n   * @default '500m' for both backend and frontend\n   */\n  readonly limitCpu?: string;\n\n  /**\n   * Memory limit for the container.\n   * @example '512Mi' or '1Gi'\n   * @default '512Mi' for backend, '1Gi' for frontend\n   */\n  readonly limitMemory?: string;\n\n  /**\n   * CPU request for the container.\n   * @example '200m' or '0.5'\n   * @default '200m'\n   */\n  readonly requestCpu?: string;\n\n  /**\n   * Memory request for the container.\n   * @example '256Mi' or '512Mi'\n   * @default '256Mi'\n   */\n  readonly requestMemory?: string;\n\n  /**\n   * Environment variables to set in the container.\n   * Use cdk8s-plus-30 Env class to define variables and sources.\n   * @default - undefined (no additional environment variables)\n   */\n  readonly environment?: kplus.Env;\n\n  /**\n   * Enable readiness probe for the container.\n   * Readiness probes determine when a container is ready to accept traffic.\n   * @default true\n   */\n  readonly readinessEnabled?: boolean;\n\n  /**\n   * Number of seconds after container start before readiness probe is initiated.\n   * @default 10\n   */\n  readonly readinessInitialDelaySeconds?: number;\n\n  /**\n   * Number of seconds after which the readiness probe times out.\n   * @default 15\n   */\n  readonly readinessTimeoutSeconds?: number;\n\n  /**\n   * How often (in seconds) to perform the readiness probe.\n   * @default 10\n   */\n  readonly readinessPeriodSeconds?: number;\n\n  /**\n   * Minimum consecutive successes for the readiness probe to be considered successful.\n   * @default 1\n   */\n  readonly readinessSuccessThreshold?: number;\n\n  /**\n   * Minimum consecutive failures for the readiness probe to be considered failed.\n   * @default 3\n   */\n  readonly readinessFailureThreshold?: number;\n\n  /**\n   * Enable liveness probe for the container.\n   * Liveness probes determine when to restart a container.\n   * Recommended: true for frontend, false for backend (Zope has its own recovery).\n   * @default false\n   */\n  readonly livenessEnabled?: boolean;\n\n  /**\n   * Number of seconds after container start before liveness probe is initiated.\n   * @default 30\n   */\n  readonly livenessInitialDelaySeconds?: number;\n\n  /**\n   * Number of seconds after which the liveness probe times out.\n   * @default 5\n   */\n  readonly livenessTimeoutSeconds?: number;\n\n  /**\n   * How often (in seconds) to perform the liveness probe.\n   * @default 10\n   */\n  readonly livenessPeriodSeconds?: number;\n\n  /**\n   * Minimum consecutive successes for the liveness probe to be considered successful.\n   * @default 1\n   */\n  readonly livenessSuccessThreshold?: number;\n\n  /**\n   * Minimum consecutive failures for the liveness probe to be considered failed.\n   * @default 3\n   */\n  readonly livenessFailureThreshold?: number;\n\n  /**\n   * Annotations to add to the Deployment metadata.\n   * @example { 'deployment.kubernetes.io/revision': '1' }\n   * @default - no additional annotations\n   */\n  readonly annotations?: { [name: string]: string };\n\n  /**\n   * Annotations to add to the Pod template metadata.\n   * Common for Prometheus, Istio, backup policies, etc.\n   * @example { 'prometheus.io/scrape': 'true', 'prometheus.io/port': '8080' }\n   * @default - no additional annotations\n   */\n  readonly podAnnotations?: { [name: string]: string };\n\n  /**\n   * Annotations to add to the Service metadata.\n   * Common for external-dns, load balancers, service mesh, etc.\n   * @example { 'external-dns.alpha.kubernetes.io/hostname': 'plone.example.com' }\n   * @default - no additional annotations\n   */\n  readonly serviceAnnotations?: { [name: string]: string };\n\n  /**\n   * Enable Prometheus ServiceMonitor for metrics collection.\n   * Requires Prometheus Operator to be installed in the cluster.\n   * When enabled, a ServiceMonitor resource will be created to scrape metrics.\n   * @default false\n   */\n  readonly servicemonitor?: boolean;\n\n  /**\n   * Port name or number to scrape metrics from.\n   * Only used when servicemonitor is enabled.\n   * @default - uses the main service port\n   */\n  readonly metricsPort?: string | number;\n\n  /**\n   * Path to scrape metrics from.\n   * Only used when servicemonitor is enabled.\n   * @default '/metrics'\n   */\n  readonly metricsPath?: string;\n}\n/**\n * Plone deployment variants.\n */\nexport enum PloneVariant {\n  /**\n   * Volto variant: ReactJS frontend (Volto) with REST API backend.\n   * Deploys both frontend and backend services.\n   */\n  VOLTO = 'volto',\n\n  /**\n   * Classic UI variant: Traditional Plone with server-side rendering.\n   * Deploys only the backend service.\n   */\n  CLASSICUI = 'classicui',\n}\n\n/**\n * Main configuration options for Plone deployment.\n */\nexport interface PloneOptions {\n  /**\n   * Version string for labeling the deployment.\n   * This is used in Kubernetes labels and doesn't affect the actual image versions.\n   * @default 'undefined'\n   */\n  readonly version?: string;\n\n  /**\n   * Plone site ID in the ZODB.\n   * This is used to construct the internal API path for Volto frontend.\n   * @default 'Plone'\n   */\n  readonly siteId?: string;\n\n  /**\n   * Plone deployment variant to use.\n   * @default PloneVariant.VOLTO\n   */\n  readonly variant?: PloneVariant;\n\n  /**\n   * Backend (Plone API) configuration.\n   * @default {} (uses default values from PloneBaseOptions)\n   */\n  readonly backend?: PloneBaseOptions;\n\n  /**\n   * Frontend (Volto) configuration.\n   * Only used when variant is PloneVariant.VOLTO.\n   * @default {} (uses default values from PloneBaseOptions)\n   */\n  readonly frontend?: PloneBaseOptions;\n\n  /**\n   * Names of Kubernetes secrets to use for pulling private container images.\n   * These secrets must exist in the same namespace as the deployment.\n   * @example ['my-registry-secret']\n   * @default [] (no image pull secrets)\n   */\n  readonly imagePullSecrets?: string[];\n}\n\n/**\n * Plone construct for deploying Plone CMS to Kubernetes.\n *\n * This construct creates all necessary Kubernetes resources for running Plone:\n * - Deployment(s) for backend (and optionally frontend)\n * - Service(s) for network access\n * - Optional PodDisruptionBudget for high availability\n *\n * Supports two deployment variants:\n * - VOLTO: Modern React frontend with REST API backend (default)\n * - CLASSICUI: Traditional server-side rendered Plone\n *\n * @example\n * new Plone(chart, 'my-plone', {\n *   variant: PloneVariant.VOLTO,\n *   backend: {\n *     image: 'plone/plone-backend:6.0.10',\n *     replicas: 3,\n *   },\n *   frontend: {\n *     image: 'plone/plone-frontend:16.0.0',\n *   },\n * });\n */\nexport class Plone extends Construct {\n  /**\n   * Name of the backend Kubernetes service.\n   * Use this to reference the backend service from other constructs.\n   */\n  public readonly backendServiceName: string;\n\n  /**\n   * Name of the frontend Kubernetes service.\n   * Only set when variant is VOLTO, otherwise undefined.\n   */\n  public readonly frontendServiceName: string | undefined;\n\n  /**\n   * The deployment variant being used (VOLTO or CLASSICUI).\n   */\n  public readonly variant: PloneVariant;\n\n  /**\n   * The Plone site ID in ZODB.\n   */\n  public readonly siteId: string;\n\n  constructor(scope: Construct, id: string, options: PloneOptions = {}) {\n    super(scope, id);\n    this.frontendServiceName = undefined;\n    this.siteId = options.siteId ?? 'Plone';\n    this.variant = options.variant ?? PloneVariant.VOLTO;\n\n    // ------------------------------------------------------------------------\n    // Backend\n    const backend = options.backend ?? {};\n    const backendLabels = {\n      'app.kubernetes.io/name': 'plone-backend',\n      'app.kubernetes.io/component': 'backend',\n      'app.kubernetes.io/version': options.version ?? 'undefined',\n    };\n    const backendPort = 8080;\n\n    // Options\n    var backendOptions: PloneDeploymentOptions = {\n      labels: backendLabels,\n      image: {\n        image: backend.image ?? 'plone/plone-backend:latest',\n        imagePullSecrets: options.imagePullSecrets ?? [],\n        imagePullPolicy: backend.imagePullPolicy ?? 'IfNotPresent',\n      },\n      replicas: backend.replicas,\n      limitCpu: backend.limitCpu ?? '500m',\n      limitMemory: backend.limitMemory ?? '512Mi',\n      requestCpu: backend.requestCpu ?? '200m',\n      requestMemory: backend.requestMemory ?? '256Mi',\n      pdb: {\n        maxUnavailable: backend.maxUnavailable ?? undefined,\n        minAvailable: backend.minAvailable ?? undefined,\n      },\n      port: backendPort,\n      environment: backend.environment,\n      annotations: backend.annotations,\n      podAnnotations: backend.podAnnotations,\n    };\n\n    // Probing\n    const backendActionHttpGet: k8s.HttpGetAction = {\n      path: '/',\n      port: IntOrString.fromNumber(backendPort),\n    };\n    if (backend.livenessEnabled ?? false) {\n      backendOptions.livenessProbe = {\n        httpGet: backendActionHttpGet,\n        initialDelaySeconds: backend.livenessInitialDelaySeconds ?? 30,\n        timeoutSeconds: backend.livenessTimeoutSeconds ?? 5,\n        periodSeconds: backend.livenessPeriodSeconds ?? 10,\n        successThreshold: backend.livenessSuccessThreshold ?? 1,\n        failureThreshold: backend.livenessFailureThreshold ?? 3,\n      };\n    }\n    if (backend.readinessEnabled ?? true) {\n      backendOptions.readinessProbe = {\n        httpGet: backendActionHttpGet,\n        initialDelaySeconds: backend.readinessInitialDelaySeconds ?? 10,\n        timeoutSeconds: backend.readinessTimeoutSeconds ?? 15,\n        periodSeconds: backend.readinessPeriodSeconds ?? 10,\n        successThreshold: backend.readinessSuccessThreshold ?? 1,\n        failureThreshold: backend.readinessFailureThreshold ?? 3,\n      };\n    }\n    // Deployment\n    var backendDeployment = new PloneDeployment(this, 'backend', backendOptions);\n\n    // Service\n    const backendService = new PloneService(backendDeployment, 'service', {\n      labels: {\n        'app.kubernetes.io/name': 'plone-backend-service',\n        'app.kubernetes.io/component': 'service',\n      },\n      targetPort: backendPort,\n      selectorLabel: { app: Names.toLabelValue(backendDeployment) },\n      portName: 'backend-http',\n      annotations: backend.serviceAnnotations,\n    });\n    this.backendServiceName = backendService.name;\n\n    // ServiceMonitor for backend\n    if (backend.servicemonitor) {\n      this.createServiceMonitor(backendService, 'backend', {\n        port: backend.metricsPort ?? 'backend-http',\n        path: backend.metricsPath ?? '/metrics',\n      });\n    }\n\n    // ------------------------------------------------------------------------\n    // Frontend\n    if (this.variant == PloneVariant.VOLTO) {\n      const frontend = options.frontend ?? {};\n      const frontendPort = 3000;\n      const frontendLabels = {\n        'app.kubernetes.io/name': 'plone-frontend',\n        'app.kubernetes.io/component': 'frontend',\n        'app.kubernetes.io/version': options.version ?? 'undefined',\n      };\n\n      // Environment for RAZZLE\n      var frontendEnvironment = frontend.environment ?? new kplus.Env([], {});\n      if (frontendEnvironment.variables.RAZZLE_INTERNAL_API_PATH === undefined) {\n        // connect with backend service\n        frontendEnvironment?.addVariable('RAZZLE_INTERNAL_API_PATH', kplus.EnvValue.fromValue(`http://${backendService.name}:${backendPort}/${this.siteId}`));\n      }\n\n      // Options\n      var frontendOptions: PloneDeploymentOptions = {\n        labels: frontendLabels,\n        image: {\n          image: frontend.image ?? 'plone/plone-frontend:latest',\n          imagePullSecrets: options.imagePullSecrets ?? [],\n          imagePullPolicy: frontend.imagePullPolicy ?? 'IfNotPresent',\n        },\n        replicas: frontend.replicas,\n        limitCpu: frontend.limitCpu ?? '500m',\n        limitMemory: frontend.limitMemory ?? '1Gi',\n        requestCpu: frontend.requestCpu ?? '200m',\n        requestMemory: frontend.requestMemory ?? '256Mi',\n\n        pdb: {\n          maxUnavailable: frontend.maxUnavailable ?? undefined,\n          minAvailable: frontend.minAvailable ?? undefined,\n        },\n        port: frontendPort,\n        environment: frontendEnvironment,\n        annotations: frontend.annotations,\n        podAnnotations: frontend.podAnnotations,\n      };\n\n      // Probing\n      const frontendActionHttpGet: k8s.HttpGetAction = {\n        path: '/',\n        port: IntOrString.fromNumber(frontendPort),\n      };\n      if (frontend.livenessEnabled ?? false) {\n        frontendOptions.livenessProbe = {\n          httpGet: frontendActionHttpGet,\n          initialDelaySeconds: frontend.livenessInitialDelaySeconds ?? 30,\n          timeoutSeconds: frontend.livenessTimeoutSeconds ?? 5,\n          periodSeconds: frontend.livenessPeriodSeconds ?? 10,\n          successThreshold: frontend.livenessSuccessThreshold ?? 1,\n          failureThreshold: frontend.livenessFailureThreshold ?? 3,\n        };\n      }\n      if (frontend.readinessEnabled ?? true) {\n        frontendOptions.readinessProbe = {\n          httpGet: frontendActionHttpGet,\n          initialDelaySeconds: frontend.readinessInitialDelaySeconds ?? 10,\n          timeoutSeconds: frontend.readinessTimeoutSeconds ?? 15,\n          periodSeconds: frontend.readinessPeriodSeconds ?? 10,\n          successThreshold: frontend.readinessSuccessThreshold ?? 1,\n          failureThreshold: frontend.readinessFailureThreshold ?? 3,\n        };\n      }\n\n      // Deployment\n      const frontendDeployment = new PloneDeployment(this, 'frontend', frontendOptions);\n\n      // Service\n      const frontendService = new PloneService(frontendDeployment, 'service', {\n        labels: {\n          'app.kubernetes.io/name': 'plone-frontend-service',\n          'app.kubernetes.io/component': 'service',\n        },\n        targetPort: frontendPort,\n        selectorLabel: { app: Names.toLabelValue(frontendDeployment) },\n        portName: 'frontend-http',\n        annotations: frontend.serviceAnnotations,\n      });\n      this.frontendServiceName = frontendService.name;\n\n      // ServiceMonitor for frontend\n      if (frontend.servicemonitor) {\n        this.createServiceMonitor(frontendService, 'frontend', {\n          port: frontend.metricsPort ?? 'frontend-http',\n          path: frontend.metricsPath ?? '/metrics',\n        });\n      }\n    }\n  }\n\n  /**\n   * Creates a Prometheus ServiceMonitor resource for the given service.\n   * @param service The PloneService to monitor\n   * @param id Unique identifier for the ServiceMonitor\n   * @param config Configuration for the ServiceMonitor\n   */\n  private createServiceMonitor(\n    service: PloneService,\n    id: string,\n    config: { port: string | number; path: string },\n  ): void {\n    const portName = typeof config.port === 'string' ? config.port : undefined;\n    const portNumber = typeof config.port === 'number'\n      ? ServiceMonitorSpecEndpointsTargetPort.fromNumber(config.port)\n      : undefined;\n\n    new ServiceMonitor(this, `servicemonitor-${id}`, {\n      metadata: {\n        name: `${service.name}-monitor`,\n        labels: {\n          'app.kubernetes.io/name': service.name,\n          'app.kubernetes.io/component': 'servicemonitor',\n        },\n      },\n      spec: {\n        selector: {\n          matchLabels: {\n            'app.kubernetes.io/name': service.labels['app.kubernetes.io/name'],\n          },\n        },\n        endpoints: [\n          {\n            ...(portName && { port: portName }),\n            ...(portNumber && { targetPort: portNumber }),\n            path: config.path,\n            interval: '30s',\n          },\n        ],\n      },\n    });\n  }\n}"]}

package/lib/vinylcache.d.ts

@@ -0,0 +1,128 @@
+import { Construct } from 'constructs';
+import { Plone } from './plone';
+/**
+ * A Kubernetes toleration for the Varnish pods.
+ */
+export interface VinylCacheToleration {
+    /**
+     * The taint key to tolerate.
+     */
+    readonly key: string;
+    /**
+     * The operator (Equal or Exists).
+     * @default 'Equal'
+     */
+    readonly operator?: string;
+    /**
+     * The taint value to match (when operator is Equal).
+     * @default - no value
+     */
+    readonly value?: string;
+    /**
+     * The taint effect to tolerate (NoSchedule, PreferNoSchedule, NoExecute).
+     * @default - tolerate all effects
+     */
+    readonly effect?: string;
+}
+/**
+ * Configuration options for PloneVinylCache (cloud-vinyl operator).
+ *
+ * Creates a VinylCache custom resource that the cloud-vinyl operator
+ * reconciles into a Varnish Cache cluster with agent-based VCL delivery.
+ *
+ * Requires the cloud-vinyl operator to be installed in the cluster.
+ */
+export interface PloneVinylCacheOptions {
+    /**
+     * The Plone construct to attach the cache to.
+     * Backends are auto-configured from the Plone services.
+     */
+    readonly plone: Plone;
+    /**
+     * Number of Varnish pod replicas.
+     * @default 2
+     */
+    readonly replicas?: number;
+    /**
+     * CPU request for Varnish pods.
+     * @default '100m'
+     */
+    readonly requestCpu?: string;
+    /**
+     * Memory request for Varnish pods.
+     * @default '256Mi'
+     */
+    readonly requestMemory?: string;
+    /**
+     * CPU limit for Varnish pods.
+     * @default '500m'
+     */
+    readonly limitCpu?: string;
+    /**
+     * Memory limit for Varnish pods.
+     * @default '512Mi'
+     */
+    readonly limitMemory?: string;
+    /**
+     * Director type for load distribution.
+     * @default 'shard'
+     */
+    readonly director?: string;
+    /**
+     * Custom VCL snippet for vcl_recv subroutine.
+     * Replaces the default Plone recv snippet.
+     * @default - uses built-in plone-vinyl-recv.vcl
+     */
+    readonly vclRecvSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_backend_response subroutine.
+     * Replaces the default Plone backend_response snippet.
+     * @default - uses built-in plone-vinyl-backend-response.vcl
+     */
+    readonly vclBackendResponseSnippet?: string;
+    /**
+     * Enable cache invalidation (PURGE, BAN, xkey).
+     * @default true
+     */
+    readonly invalidation?: boolean;
+    /**
+     * Enable Prometheus monitoring (metrics + ServiceMonitor).
+     * @default false
+     */
+    readonly monitoring?: boolean;
+    /**
+     * Container image for the Varnish pods.
+     * @default 'varnish:7.6'
+     */
+    readonly image?: string;
+    /**
+     * Tolerations for the Varnish pods.
+     * @default - no tolerations
+     */
+    readonly tolerations?: VinylCacheToleration[];
+}
+/**
+ * PloneVinylCache construct for deploying Varnish Cache via cloud-vinyl operator.
+ *
+ * Creates a VinylCache custom resource with Plone backend/frontend services
+ * auto-configured as backends. The cloud-vinyl operator manages the full
+ * Varnish lifecycle including VCL generation, agent delivery, and monitoring.
+ *
+ * Requires the cloud-vinyl operator to be installed in the cluster.
+ *
+ * @example
+ * const plone = new Plone(chart, 'plone');
+ * const cache = new PloneVinylCache(chart, 'cache', {
+ *   plone: plone,
+ *   replicas: 2,
+ * });
+ * // Use cache.vinylCacheServiceName for IngressRoute
+ */
+export declare class PloneVinylCache extends Construct {
+    /**
+     * Name of the VinylCache service created by the operator.
+     * Use this to reference the cache service from ingress or other constructs.
+     */
+    readonly vinylCacheServiceName: string;
+    constructor(scope: Construct, id: string, options: PloneVinylCacheOptions);
+}

package/lib/vinylcache.js

@@ -0,0 +1,132 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PloneVinylCache = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs = require("fs");
+const path = require("path");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const vinyl_bluedynamics_eu_1 = require("./imports/vinyl.bluedynamics.eu");
+/**
+ * PloneVinylCache construct for deploying Varnish Cache via cloud-vinyl operator.
+ *
+ * Creates a VinylCache custom resource with Plone backend/frontend services
+ * auto-configured as backends. The cloud-vinyl operator manages the full
+ * Varnish lifecycle including VCL generation, agent delivery, and monitoring.
+ *
+ * Requires the cloud-vinyl operator to be installed in the cluster.
+ *
+ * @example
+ * const plone = new Plone(chart, 'plone');
+ * const cache = new PloneVinylCache(chart, 'cache', {
+ *   plone: plone,
+ *   replicas: 2,
+ * });
+ * // Use cache.vinylCacheServiceName for IngressRoute
+ */
+class PloneVinylCache extends constructs_1.Construct {
+    constructor(scope, id, options) {
+        super(scope, id);
+        const replicas = options.replicas ?? 2;
+        const invalidation = options.invalidation ?? true;
+        const monitoring = options.monitoring ?? false;
+        // Resolve director type enum
+        const directorStr = options.director ?? 'shard';
+        let directorType;
+        switch (directorStr) {
+            case 'round_robin':
+                directorType = vinyl_bluedynamics_eu_1.VinylCacheSpecDirectorType.ROUND_UNDERSCORE_ROBIN;
+                break;
+            case 'random':
+                directorType = vinyl_bluedynamics_eu_1.VinylCacheSpecDirectorType.RANDOM;
+                break;
+            case 'hash':
+                directorType = vinyl_bluedynamics_eu_1.VinylCacheSpecDirectorType.HASH;
+                break;
+            default:
+                directorType = vinyl_bluedynamics_eu_1.VinylCacheSpecDirectorType.SHARD;
+        }
+        // Load default VCL snippets
+        const vclRecv = options.vclRecvSnippet ??
+            fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-recv.vcl'), 'utf8');
+        const vclBackendResponse = options.vclBackendResponseSnippet ??
+            fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-backend-response.vcl'), 'utf8');
+        // Build backends from Plone services
+        const backends = [
+            {
+                name: 'plone_backend',
+                serviceRef: { name: options.plone.backendServiceName },
+                port: 8080,
+                probe: {
+                    url: '/ok',
+                    interval: '5s',
+                    timeout: '2s',
+                    window: 10,
+                    threshold: 8,
+                },
+            },
+        ];
+        if (options.plone.frontendServiceName) {
+            backends.push({
+                name: 'plone_frontend',
+                serviceRef: { name: options.plone.frontendServiceName },
+                port: 3000,
+                probe: {
+                    url: '/',
+                    interval: '5s',
+                    timeout: '2s',
+                    window: 10,
+                    threshold: 8,
+                },
+            });
+        }
+        const vinylCache = new vinyl_bluedynamics_eu_1.VinylCache(this, 'vinylcache', {
+            spec: {
+                replicas,
+                image: options.image ?? 'varnish:7.6',
+                backends,
+                director: { type: directorType },
+                vcl: {
+                    snippets: {
+                        vclRecv: vclRecv,
+                        vclBackendResponse: vclBackendResponse,
+                    },
+                },
+                resources: {
+                    requests: {
+                        cpu: vinyl_bluedynamics_eu_1.VinylCacheSpecResourcesRequests.fromString(options.requestCpu ?? '100m'),
+                        memory: vinyl_bluedynamics_eu_1.VinylCacheSpecResourcesRequests.fromString(options.requestMemory ?? '256Mi'),
+                    },
+                    limits: {
+                        cpu: vinyl_bluedynamics_eu_1.VinylCacheSpecResourcesLimits.fromString(options.limitCpu ?? '500m'),
+                        memory: vinyl_bluedynamics_eu_1.VinylCacheSpecResourcesLimits.fromString(options.limitMemory ?? '512Mi'),
+                    },
+                },
+                invalidation: invalidation ? {
+                    purge: { enabled: true },
+                    ban: { enabled: true },
+                    xkey: { enabled: true },
+                } : undefined,
+                monitoring: monitoring ? {
+                    enabled: true,
+                    serviceMonitor: { enabled: true },
+                } : undefined,
+                pod: (options.tolerations && options.tolerations.length > 0) ? {
+                    tolerations: options.tolerations.map(t => ({
+                        key: t.key,
+                        operator: t.operator,
+                        value: t.value,
+                        effect: t.effect,
+                    })),
+                } : undefined,
+            },
+        });
+        // The operator creates a service with the same name as the VinylCache resource
+        this.vinylCacheServiceName = cdk8s_1.Names.toLabelValue(vinylCache);
+    }
+}
+exports.PloneVinylCache = PloneVinylCache;
+_a = JSII_RTTI_SYMBOL_1;
+PloneVinylCache[_a] = { fqn: "@bluedynamics/cdk8s-plone.PloneVinylCache", version: "0.1.24" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vinylcache.js","sourceRoot":"","sources":["../src/vinylcache.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Names } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport {\n  VinylCache,\n  VinylCacheSpecDirectorType,\n  VinylCacheSpecResourcesLimits,\n  VinylCacheSpecResourcesRequests,\n} from './imports/vinyl.bluedynamics.eu';\nimport { Plone } from './plone';\n\n/**\n * A Kubernetes toleration for the Varnish pods.\n */\nexport interface VinylCacheToleration {\n  /**\n   * The taint key to tolerate.\n   */\n  readonly key: string;\n\n  /**\n   * The operator (Equal or Exists).\n   * @default 'Equal'\n   */\n  readonly operator?: string;\n\n  /**\n   * The taint value to match (when operator is Equal).\n   * @default - no value\n   */\n  readonly value?: string;\n\n  /**\n   * The taint effect to tolerate (NoSchedule, PreferNoSchedule, NoExecute).\n   * @default - tolerate all effects\n   */\n  readonly effect?: string;\n}\n\n/**\n * Configuration options for PloneVinylCache (cloud-vinyl operator).\n *\n * Creates a VinylCache custom resource that the cloud-vinyl operator\n * reconciles into a Varnish Cache cluster with agent-based VCL delivery.\n *\n * Requires the cloud-vinyl operator to be installed in the cluster.\n */\nexport interface PloneVinylCacheOptions {\n  /**\n   * The Plone construct to attach the cache to.\n   * Backends are auto-configured from the Plone services.\n   */\n  readonly plone: Plone;\n\n  /**\n   * Number of Varnish pod replicas.\n   * @default 2\n   */\n  readonly replicas?: number;\n\n  /**\n   * CPU request for Varnish pods.\n   * @default '100m'\n   */\n  readonly requestCpu?: string;\n\n  /**\n   * Memory request for Varnish pods.\n   * @default '256Mi'\n   */\n  readonly requestMemory?: string;\n\n  /**\n   * CPU limit for Varnish pods.\n   * @default '500m'\n   */\n  readonly limitCpu?: string;\n\n  /**\n   * Memory limit for Varnish pods.\n   * @default '512Mi'\n   */\n  readonly limitMemory?: string;\n\n  /**\n   * Director type for load distribution.\n   * @default 'shard'\n   */\n  readonly director?: string;\n\n  /**\n   * Custom VCL snippet for vcl_recv subroutine.\n   * Replaces the default Plone recv snippet.\n   * @default - uses built-in plone-vinyl-recv.vcl\n   */\n  readonly vclRecvSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_backend_response subroutine.\n   * Replaces the default Plone backend_response snippet.\n   * @default - uses built-in plone-vinyl-backend-response.vcl\n   */\n  readonly vclBackendResponseSnippet?: string;\n\n  /**\n   * Enable cache invalidation (PURGE, BAN, xkey).\n   * @default true\n   */\n  readonly invalidation?: boolean;\n\n  /**\n   * Enable Prometheus monitoring (metrics + ServiceMonitor).\n   * @default false\n   */\n  readonly monitoring?: boolean;\n\n  /**\n   * Container image for the Varnish pods.\n   * @default 'varnish:7.6'\n   */\n  readonly image?: string;\n\n  /**\n   * Tolerations for the Varnish pods.\n   * @default - no tolerations\n   */\n  readonly tolerations?: VinylCacheToleration[];\n}\n\n/**\n * PloneVinylCache construct for deploying Varnish Cache via cloud-vinyl operator.\n *\n * Creates a VinylCache custom resource with Plone backend/frontend services\n * auto-configured as backends. The cloud-vinyl operator manages the full\n * Varnish lifecycle including VCL generation, agent delivery, and monitoring.\n *\n * Requires the cloud-vinyl operator to be installed in the cluster.\n *\n * @example\n * const plone = new Plone(chart, 'plone');\n * const cache = new PloneVinylCache(chart, 'cache', {\n *   plone: plone,\n *   replicas: 2,\n * });\n * // Use cache.vinylCacheServiceName for IngressRoute\n */\nexport class PloneVinylCache extends Construct {\n  /**\n   * Name of the VinylCache service created by the operator.\n   * Use this to reference the cache service from ingress or other constructs.\n   */\n  public readonly vinylCacheServiceName: string;\n\n  constructor(scope: Construct, id: string, options: PloneVinylCacheOptions) {\n    super(scope, id);\n\n    const replicas = options.replicas ?? 2;\n    const invalidation = options.invalidation ?? true;\n    const monitoring = options.monitoring ?? false;\n\n    // Resolve director type enum\n    const directorStr = options.director ?? 'shard';\n    let directorType: VinylCacheSpecDirectorType;\n    switch (directorStr) {\n      case 'round_robin':\n        directorType = VinylCacheSpecDirectorType.ROUND_UNDERSCORE_ROBIN;\n        break;\n      case 'random':\n        directorType = VinylCacheSpecDirectorType.RANDOM;\n        break;\n      case 'hash':\n        directorType = VinylCacheSpecDirectorType.HASH;\n        break;\n      default:\n        directorType = VinylCacheSpecDirectorType.SHARD;\n    }\n\n    // Load default VCL snippets\n    const vclRecv = options.vclRecvSnippet ??\n      fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-recv.vcl'), 'utf8');\n    const vclBackendResponse = options.vclBackendResponseSnippet ??\n      fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-backend-response.vcl'), 'utf8');\n\n    // Build backends from Plone services\n    const backends = [\n      {\n        name: 'plone_backend',\n        serviceRef: { name: options.plone.backendServiceName },\n        port: 8080,\n        probe: {\n          url: '/ok',\n          interval: '5s',\n          timeout: '2s',\n          window: 10,\n          threshold: 8,\n        },\n      },\n    ];\n\n    if (options.plone.frontendServiceName) {\n      backends.push({\n        name: 'plone_frontend',\n        serviceRef: { name: options.plone.frontendServiceName },\n        port: 3000,\n        probe: {\n          url: '/',\n          interval: '5s',\n          timeout: '2s',\n          window: 10,\n          threshold: 8,\n        },\n      });\n    }\n\n    const vinylCache = new VinylCache(this, 'vinylcache', {\n      spec: {\n        replicas,\n        image: options.image ?? 'varnish:7.6',\n        backends,\n        director: { type: directorType },\n        vcl: {\n          snippets: {\n            vclRecv: vclRecv,\n            vclBackendResponse: vclBackendResponse,\n          },\n        },\n        resources: {\n          requests: {\n            cpu: VinylCacheSpecResourcesRequests.fromString(options.requestCpu ?? '100m'),\n            memory: VinylCacheSpecResourcesRequests.fromString(options.requestMemory ?? '256Mi'),\n          },\n          limits: {\n            cpu: VinylCacheSpecResourcesLimits.fromString(options.limitCpu ?? '500m'),\n            memory: VinylCacheSpecResourcesLimits.fromString(options.limitMemory ?? '512Mi'),\n          },\n        },\n        invalidation: invalidation ? {\n          purge: { enabled: true },\n          ban: { enabled: true },\n          xkey: { enabled: true },\n        } : undefined,\n        monitoring: monitoring ? {\n          enabled: true,\n          serviceMonitor: { enabled: true },\n        } : undefined,\n        pod: (options.tolerations && options.tolerations.length > 0) ? {\n          tolerations: options.tolerations.map(t => ({\n            key: t.key,\n            operator: t.operator,\n            value: t.value,\n            effect: t.effect,\n          })),\n        } : undefined,\n      },\n    });\n\n    // The operator creates a service with the same name as the VinylCache resource\n    this.vinylCacheServiceName = Names.toLabelValue(vinylCache);\n  }\n}\n"]}

package/package.json

@@ -16,6 +16,7 @@
     "eject": "npx projen eject",
     "eslint": "npx projen eslint",
     "import:servicemonitor": "npx projen import:servicemonitor",
+    "import:vinylcache": "npx projen import:vinylcache",
     "package": "npx projen package",
     "package-all": "npx projen package-all",
     "package:js": "npx projen package:js",
@@ -42,7 +43,7 @@
     "@types/node": "^18",
     "@typescript-eslint/eslint-plugin": "^8",
     "@typescript-eslint/parser": "^8",
-    "cdk8s-cli": "^2.205.1",
+    "cdk8s-cli": "^2.206.0",
     "cdk8s-plus-30": "^2.4.10",
     "commit-and-tag-version": "^12",
     "constructs": "10.4.2",
@@ -56,8 +57,8 @@
     "jsii-docgen": "^10.5.0",
     "jsii-pacmak": "^1.127.0",
     "jsii-rosetta": "~5.9.11",
-    "projen": "^0.99.21",
-    "ts-jest": "^29.4.6",
+    "projen": "^0.99.35",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
     "yaml": "^2.8.1"
@@ -67,7 +68,7 @@
     "constructs": "^10.4.2"
   },
   "dependencies": {
-    "cdk8s": "^2.70.52",
+    "cdk8s": "^2.70.54",
     "cdk8s-plus-30": "^2.4.10",
     "constructs": "^10.4.2"
   },
@@ -76,7 +77,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.22",
+  "version": "0.1.24",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [