cdk8s-aws-cdk 0.0.5

package/lib/adapter.js

@@ -0,0 +1,196 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsCdkAdapater = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws = require("aws-cdk-lib");
+const k = require("cdk8s");
+const kplus = require("cdk8s-plus-24");
+const kfieldexports = require("./imports/fieldexports-services.k8s.aws");
+const mappers = require("./mappers");
+class AwsCdkAdapater extends aws.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this._mappers = {};
+        this.chart = props.chart;
+        this.registerMapper(new mappers.RdsDBInstanceMapper(this.chart));
+        this.registerMapper(new mappers.Ec2SecurityGroupMapper(this.chart));
+        this.registerMapper(new mappers.RdsDBSubnetGroup(this.chart));
+        this.registerMapper(new mappers.IamPolicyMapper(this.chart));
+        this.registerMapper(new mappers.IamRoleMapper(this.chart));
+        this.registerMapper(new mappers.LambdaFunctionMapper(this.chart));
+        this.registerMapper(new mappers.S3BucketMapper(this.chart));
+    }
+    /**
+     * Register a mapper that can transform a specific CloudFormation resource type.
+     */
+    registerMapper(mapper) {
+        this._mappers[mapper.type] = mapper;
+    }
+    /**
+     * Transform CloudFormation resources to ACK resources.
+     */
+    transformResources(cfnResources) {
+        for (const cfnResource of cfnResources) {
+            const logicalId = this.getLogicalId(cfnResource);
+            const cfnType = cfnResource.cfnResourceType;
+            const mapper = this.tryFindMapper(cfnType);
+            if (!mapper) {
+                throw new Error(`Unable to transform resource of type '${cfnType}'. Mapper is not registered`);
+            }
+            const cfnTemplateResources = Object.values(cfnResource._toCloudFormation().Resources);
+            const cfnProperties = this.resolveIntrinsics(logicalId, this.resolve(cfnTemplateResources[0].value.Properties.value), mapper);
+            const resource = mapper.map(logicalId, cfnProperties);
+            // for each resource we patch its name if needed
+            if (!cfnProperties[mapper.nameMapping.cfnProperty]) {
+                resource.addJsonPatch(k.JsonPatch.add(mapper.nameMapping.specPath, resource.name));
+                resource.addJsonPatch(k.JsonPatch.add('/metadata', { name: resource.name }));
+            }
+            // for each resource we create a config map that will hold its field exports.
+            // i.e runtime attributes. these will later be used to transform CloudFormation
+            // attributes.
+            const configMap = new kplus.ConfigMap(this.chart, `${logicalId}ConfigMap`);
+            for (const exportMapping of mapper.exportMappings) {
+                new kfieldexports.FieldExport(this.chart, this.fieldExportId(logicalId, exportMapping.attribute), {
+                    spec: {
+                        from: {
+                            path: this.fieldExportPath(exportMapping.field),
+                            resource: { group: resource.apiGroup, kind: resource.kind, name: resource.name },
+                        },
+                        to: {
+                            kind: kfieldexports.FieldExportSpecToKind.CONFIGMAP,
+                            name: configMap.name,
+                        },
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Transform CloudFormation attributes into ACK field exports.
+     *
+     * Note that this is only supported for container environment variables,
+     * as only they allow referencing fields from config maps, which the field exports export to.
+     *
+     * If an ApiObject contains a CloudFormation attribute in any other definition, it will remain
+     * as is, it will remain in-place.
+     */
+    transformAttributes(apiObjects) {
+        var _b, _c, _d, _e;
+        for (const apiObject of apiObjects) {
+            const spec = apiObject.toJson().spec;
+            switch (apiObject.kind) {
+                case 'Deployment':
+                case 'StatefulSet':
+                case 'DaemonSet':
+                case 'Job':
+                    this.patchContainerEnvironment(apiObject, (_d = (_c = (_b = spec === null || spec === void 0 ? void 0 : spec.template) === null || _b === void 0 ? void 0 : _b.spec) === null || _c === void 0 ? void 0 : _c.containers) !== null && _d !== void 0 ? _d : [], '/spec/template/spec/containers');
+                    break;
+                case 'Pod':
+                    this.patchContainerEnvironment(apiObject, (_e = spec === null || spec === void 0 ? void 0 : spec.containers) !== null && _e !== void 0 ? _e : [], '/spec/containers');
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    patchContainerEnvironment(resource, containers, path) {
+        var _b, _c;
+        for (let i = 0; i < containers.length; i++) {
+            const container = containers[i];
+            const envVars = (_b = container.env) !== null && _b !== void 0 ? _b : [];
+            for (let j = 0; j < envVars.length; j++) {
+                const envVar = envVars[j];
+                if (!envVar.value) {
+                    // we only conver value --> valueFrom
+                    continue;
+                }
+                if (!aws.Token.isUnresolved(envVar.value)) {
+                    // no conversion necessary
+                    continue;
+                }
+                const resolved = this.resolve(envVar.value);
+                if (typeof (resolved) !== 'object') {
+                    // not sure what this means...skip in the meantime
+                    continue;
+                }
+                const key = Object.keys(resolved)[0];
+                if (!key.startsWith('Fn::GetAtt')) {
+                    // not sure what this means...skip in the meantime
+                    continue;
+                }
+                const value = Object.values(resolved)[0];
+                const logicalId = value[0];
+                const attribute = value[1];
+                // locate the field exports that is mapped to this attribute.
+                const fieldExport = this.tryFindFieldExport(logicalId, attribute);
+                if (!fieldExport) {
+                    throw new Error(`Unable to transform attribute '${JSON.stringify(resolved)}' for env variable '${envVar.name}' in resource '${resource.name}': Field export not registered.`);
+                }
+                const fieldExportSpec = fieldExport.toJson().spec;
+                const namespace = (_c = fieldExport.metadata.namespace) !== null && _c !== void 0 ? _c : 'default';
+                resource.addJsonPatch(k.JsonPatch.remove(`${path}/${i}/env/${j}`));
+                resource.addJsonPatch(k.JsonPatch.add(`${path}/${i}/env/${j}`, {
+                    name: envVar.name,
+                    valueFrom: {
+                        configMapKeyRef: {
+                            key: `${namespace}.${fieldExport.name}`,
+                            name: fieldExportSpec.to.name,
+                        },
+                    },
+                }));
+            }
+        }
+    }
+    resolveIntrinsics(logicalId, properties, mapper) {
+        const resolved = JSON.stringify(properties, (key, value) => {
+            if (typeof (value) !== 'object') {
+                // not an attribute
+                return value;
+            }
+            if (Object.keys(value).length !== 1) {
+                // definitely not an intrinsic, which takes the form '{ key: value }'
+                return value;
+            }
+            const attribute = Object.keys(value)[0];
+            const refLogicalId = Object.values(value)[0];
+            if (attribute.startsWith('Fn::')) {
+                // ACK doesn't have support for Fn:: intrinsics at the moment.
+                // actually -- thats not entirely true, some resources do have a way to pass
+                // values by referencing other resources. For example, you can pass a `vpcRef`
+                // to a security group, instead of the actual vpc id. but I have yet to list those out,
+                // and understand how they work.
+                throw new Error(`Unable to resolve intrinsic function '${JSON.stringify(value)}' in property '${key}' of resource '${logicalId}'`);
+            }
+            if (attribute !== 'Ref') {
+                // probably just a complext value, move on...
+                return value;
+            }
+            // we can resolve 'Ref' because we know all resource names at synth time.
+            const reference = this.chart.node.findChild(refLogicalId);
+            switch (mapper.refMapping) {
+                case mappers.CloudFormationMapperRefMapping.NAME:
+                    return k.ApiObject.of(reference).name;
+                default:
+                    throw new Error(`Unsupported ref mapping: ${mapper.refMapping}`);
+            }
+        });
+        return JSON.parse(resolved);
+    }
+    tryFindMapper(cfnType) {
+        return this._mappers[cfnType];
+    }
+    tryFindFieldExport(logicalId, attr) {
+        return this.chart.node.tryFindChild(this.fieldExportId(logicalId, attr));
+    }
+    fieldExportId(logicalId, attribute) {
+        return `${logicalId}${attribute}`;
+    }
+    fieldExportPath(field) {
+        return `.status.${field}`;
+    }
+}
+exports.AwsCdkAdapater = AwsCdkAdapater;
+_a = JSII_RTTI_SYMBOL_1;
+AwsCdkAdapater[_a] = { fqn: "cdk8s-aws-cdk.AwsCdkAdapater", version: "0.0.5" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as aws from 'aws-cdk-lib';\nimport * as k from 'cdk8s';\nimport * as kplus from 'cdk8s-plus-24';\nimport { Construct } from 'constructs';\nimport * as kfieldexports from './imports/fieldexports-services.k8s.aws';\nimport * as k8s from './imports/k8s';\nimport * as mappers from './mappers';\n\nexport interface AwsCdkAdapterProps extends aws.StackProps {\n\n  readonly chart: k.Chart;\n}\n\nexport class AwsCdkAdapater extends aws.Stack {\n\n  private readonly chart: k.Chart;\n\n  private readonly _mappers: Record<string, mappers.CloudFormationResourceMapper> = {};\n\n  constructor(scope: Construct, id: string, props: AwsCdkAdapterProps) {\n    super(scope, id, props);\n    this.chart = props.chart;\n\n    this.registerMapper(new mappers.RdsDBInstanceMapper(this.chart));\n    this.registerMapper(new mappers.Ec2SecurityGroupMapper(this.chart));\n    this.registerMapper(new mappers.RdsDBSubnetGroup(this.chart));\n    this.registerMapper(new mappers.IamPolicyMapper(this.chart));\n    this.registerMapper(new mappers.IamRoleMapper(this.chart));\n    this.registerMapper(new mappers.LambdaFunctionMapper(this.chart));\n    this.registerMapper(new mappers.S3BucketMapper(this.chart));\n  }\n\n  /**\n   * Register a mapper that can transform a specific CloudFormation resource type.\n   */\n  public registerMapper(mapper: mappers.CloudFormationResourceMapper) {\n    this._mappers[mapper.type] = mapper;\n  }\n\n  /**\n   * Transform CloudFormation resources to ACK resources.\n   */\n  public transformResources(cfnResources: aws.CfnResource[]) {\n\n    for (const cfnResource of cfnResources) {\n      const logicalId = this.getLogicalId(cfnResource);\n      const cfnType = cfnResource.cfnResourceType;\n\n      const mapper = this.tryFindMapper(cfnType);\n\n      if (!mapper) {\n        throw new Error(`Unable to transform resource of type '${cfnType}'. Mapper is not registered`);\n      }\n\n      const cfnTemplateResources = Object.values((cfnResource._toCloudFormation() as any).Resources) as any[];\n      const cfnProperties = this.resolveIntrinsics(logicalId, this.resolve(cfnTemplateResources[0].value.Properties.value), mapper);\n\n      const resource = mapper.map(logicalId, cfnProperties);\n\n      // for each resource we patch its name if needed\n      if (!cfnProperties[mapper.nameMapping.cfnProperty]) {\n        resource.addJsonPatch(k.JsonPatch.add(mapper.nameMapping.specPath, resource.name));\n        resource.addJsonPatch(k.JsonPatch.add('/metadata', { name: resource.name }));\n      }\n\n      // for each resource we create a config map that will hold its field exports.\n      // i.e runtime attributes. these will later be used to transform CloudFormation\n      // attributes.\n      const configMap = new kplus.ConfigMap(this.chart, `${logicalId}ConfigMap`);\n\n      for (const exportMapping of mapper.exportMappings) {\n        new kfieldexports.FieldExport(this.chart, this.fieldExportId(logicalId, exportMapping.attribute), {\n          spec: {\n            from: {\n              path: this.fieldExportPath(exportMapping.field),\n              resource: { group: resource.apiGroup, kind: resource.kind, name: resource.name },\n            },\n            to: {\n              kind: kfieldexports.FieldExportSpecToKind.CONFIGMAP,\n              name: configMap.name,\n            },\n          },\n        });\n      }\n    }\n  }\n\n  /**\n   * Transform CloudFormation attributes into ACK field exports.\n   *\n   * Note that this is only supported for container environment variables,\n   * as only they allow referencing fields from config maps, which the field exports export to.\n   *\n   * If an ApiObject contains a CloudFormation attribute in any other definition, it will remain\n   * as is, it will remain in-place.\n   */\n  public transformAttributes(apiObjects: k.ApiObject[]) {\n\n    for (const apiObject of apiObjects) {\n\n      const spec: any = apiObject.toJson().spec;\n\n      switch (apiObject.kind) {\n        case 'Deployment':\n        case 'StatefulSet':\n        case 'DaemonSet':\n        case 'Job':\n          this.patchContainerEnvironment(apiObject, spec?.template?.spec?.containers ?? [], '/spec/template/spec/containers');\n          break;\n        case 'Pod':\n          this.patchContainerEnvironment(apiObject, spec?.containers ?? [], '/spec/containers');\n          break;\n        default:\n          break;\n      }\n    }\n  }\n\n  private patchContainerEnvironment(resource: k.ApiObject, containers: k8s.Container[], path: string) {\n\n    for (let i = 0; i < containers.length; i++) {\n\n      const container = containers[i];\n      const envVars = container.env ?? [];\n\n      for (let j = 0; j < envVars.length; j++) {\n\n        const envVar = envVars[j];\n\n        if (!envVar.value) {\n          // we only conver value --> valueFrom\n          continue;\n        }\n\n        if (!aws.Token.isUnresolved(envVar.value)) {\n          // no conversion necessary\n          continue;\n        }\n\n        const resolved = this.resolve(envVar.value);\n\n        if (typeof(resolved) !== 'object') {\n          // not sure what this means...skip in the meantime\n          continue;\n        }\n\n        const key = Object.keys(resolved)[0];\n        if (!key.startsWith('Fn::GetAtt')) {\n          // not sure what this means...skip in the meantime\n          continue;\n        }\n\n        const value = Object.values(resolved)[0] as string[];\n        const logicalId = value[0];\n        const attribute = value[1];\n\n        // locate the field exports that is mapped to this attribute.\n        const fieldExport = this.tryFindFieldExport(logicalId, attribute);\n        if (!fieldExport) {\n          throw new Error(`Unable to transform attribute '${JSON.stringify(resolved)}' for env variable '${envVar.name}' in resource '${resource.name}': Field export not registered.`);\n        }\n\n        const fieldExportSpec: kfieldexports.FieldExportSpec = fieldExport.toJson().spec;\n        const namespace = fieldExport.metadata.namespace ?? 'default';\n\n        resource.addJsonPatch(k.JsonPatch.remove(`${path}/${i}/env/${j}`));\n        resource.addJsonPatch(k.JsonPatch.add(`${path}/${i}/env/${j}`, {\n          name: envVar.name,\n          valueFrom: {\n            configMapKeyRef: {\n              key: `${namespace}.${fieldExport.name}`,\n              name: fieldExportSpec.to.name,\n            },\n          },\n        }));\n      }\n    }\n  }\n\n  private resolveIntrinsics(logicalId: string, properties: any, mapper: mappers.CloudFormationResourceMapper) {\n\n    const resolved = JSON.stringify(properties, (key, value) => {\n\n      if (typeof(value) !== 'object') {\n        // not an attribute\n        return value;\n      }\n\n      if (Object.keys(value).length !== 1) {\n        // definitely not an intrinsic, which takes the form '{ key: value }'\n        return value;\n      }\n\n      const attribute = Object.keys(value)[0];\n      const refLogicalId = Object.values(value)[0];\n\n      if (attribute.startsWith('Fn::')) {\n        // ACK doesn't have support for Fn:: intrinsics at the moment.\n        // actually -- thats not entirely true, some resources do have a way to pass\n        // values by referencing other resources. For example, you can pass a `vpcRef`\n        // to a security group, instead of the actual vpc id. but I have yet to list those out,\n        // and understand how they work.\n        throw new Error(`Unable to resolve intrinsic function '${JSON.stringify(value)}' in property '${key}' of resource '${logicalId}'`);\n      }\n\n      if (attribute !== 'Ref') {\n        // probably just a complext value, move on...\n        return value;\n      }\n\n      // we can resolve 'Ref' because we know all resource names at synth time.\n      const reference = this.chart.node.findChild(refLogicalId as string);\n      switch (mapper.refMapping) {\n        case mappers.CloudFormationMapperRefMapping.NAME:\n          return k.ApiObject.of(reference).name;\n        default:\n          throw new Error(`Unsupported ref mapping: ${mapper.refMapping}`);\n      }\n    });\n\n    return JSON.parse(resolved);\n\n  }\n\n  private tryFindMapper(cfnType: string): mappers.CloudFormationResourceMapper {\n    return this._mappers[cfnType];\n  }\n\n  private tryFindFieldExport(logicalId: string, attr: string): kfieldexports.FieldExport {\n    return this.chart.node.tryFindChild(this.fieldExportId(logicalId, attr)) as kfieldexports.FieldExport;\n  }\n\n  private fieldExportId(logicalId: string, attribute: string) {\n    return `${logicalId}${attribute}`;\n  }\n\n  private fieldExportPath(field: string) {\n    return `.status.${field}`;\n  }\n\n}\n"]}

package/lib/chart.d.ts

@@ -0,0 +1,19 @@
+import * as k from 'cdk8s';
+import { Construct } from 'constructs';
+import * as adapter from './adapter';
+import * as mappers from './mappers';
+export declare class Chart extends k.Chart {
+    protected readonly adapter: adapter.AwsCdkAdapater;
+    constructor(scope: Construct, id: string, props?: k.ChartProps);
+    private _validate;
+    /**
+     * Monkey patches the chart to also inherit from an AWS CDK stack.
+     * This makes it so the chart can be passed as a scope of AWS CDK constructs.
+     */
+    private _inheritStack;
+    /**
+     * Registers a new mapper.
+     */
+    protected registerMapper(mapper: mappers.CloudFormationResourceMapper): void;
+}
+//# sourceMappingURL=chart.d.ts.map

package/lib/chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart.d.ts","sourceRoot":"","sources":["../src/chart.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAIrC,qBAAa,KAAM,SAAQ,CAAC,CAAC,KAAK;IAEhC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC;gBAEvC,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,GAAE,CAAC,CAAC,UAAgB;IAUnE,OAAO,CAAC,SAAS;IAejB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAsBrB;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,4BAA4B;CAItE"}

package/lib/chart.js

@@ -0,0 +1,63 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chart = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws = require("aws-cdk-lib");
+const k = require("cdk8s");
+const adapter = require("./adapter");
+const STACK_SYMBOL = Symbol.for('@aws-cdk/core.Stack');
+class Chart extends k.Chart {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.adapter = new adapter.AwsCdkAdapater(this, 'AwsCdkAdapter', { chart: this });
+        this._inheritStack();
+        // hack that allows us to inject code just before cdk8s synthesis.
+        // TODO - figure out a proper hook for synthesis in cdk8s (or maybe constructs?)
+        this.node.addValidation({ validate: () => this._validate() });
+    }
+    _validate() {
+        const cfnResources = this.node.findAll().filter(n => aws.CfnResource.isCfnResource(n));
+        const apiObjects = this.node.findAll().filter(n => n instanceof k.ApiObject);
+        // transform all cfn resources to ack resources
+        this.adapter.transformResources(cfnResources);
+        // transform cfn attributes to field exports
+        this.adapter.transformAttributes(apiObjects);
+        // hack, we need to return something...
+        return [];
+    }
+    /**
+     * Monkey patches the chart to also inherit from an AWS CDK stack.
+     * This makes it so the chart can be passed as a scope of AWS CDK constructs.
+     */
+    _inheritStack() {
+        Object.defineProperty(this, STACK_SYMBOL, { value: true });
+        const stackMethods = Object.getOwnPropertyNames(Object.getPrototypeOf(Object.getPrototypeOf(this.adapter)));
+        const adapterProperties = Object.getOwnPropertyNames(this.adapter);
+        for (const p of [...stackMethods, ...adapterProperties]) {
+            if (['constructor', 'node'].includes(p)) {
+                continue;
+            }
+            ;
+            const v = this.adapter[p];
+            if (typeof (v) === 'function') {
+                // this is...adventurous? yeah...
+                const n = new Function('...args', `return this.adapter.${p}(...args);`);
+                Object.defineProperty(this, p, { value: n });
+            }
+            else {
+                Object.defineProperty(this, p, { value: v });
+            }
+        }
+    }
+    /**
+     * Registers a new mapper.
+     */
+    registerMapper(mapper) {
+        this.adapter.registerMapper(mapper);
+    }
+}
+exports.Chart = Chart;
+_a = JSII_RTTI_SYMBOL_1;
+Chart[_a] = { fqn: "cdk8s-aws-cdk.Chart", version: "0.0.5" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/imports/cloudcontrol.services.k8s.aws.d.ts

@@ -0,0 +1,106 @@
+import { ApiObject, ApiObjectMetadata, GroupVersionKind } from 'cdk8s';
+import { Construct } from 'constructs';
+/**
+ * Resource is the Schema for the Resources API
+ *
+ * @schema Resource
+ */
+export declare class Resource extends ApiObject {
+    /**
+     * Returns the apiVersion and kind for "Resource"
+     */
+    static readonly GVK: GroupVersionKind;
+    /**
+     * Renders a Kubernetes manifest for "Resource".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props?: ResourceProps): any;
+    /**
+     * Defines a "Resource" API object
+     * @param scope the scope in which to define this object
+     * @param id a scope-local name for the object
+     * @param props initialization props
+     */
+    constructor(scope: Construct, id: string, props?: ResourceProps);
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson(): any;
+}
+/**
+ * Resource is the Schema for the Resources API
+ *
+ * @schema Resource
+ */
+export interface ResourceProps {
+    /**
+     * @schema Resource#metadata
+     */
+    readonly metadata?: ApiObjectMetadata;
+    /**
+     * ResourceSpec defines the desired state of Resource.
+     *
+     * @schema Resource#spec
+     */
+    readonly spec?: ResourceSpec;
+}
+/**
+ * Converts an object of type 'ResourceProps' to JSON representation.
+ */
+export declare function toJson_ResourceProps(obj: ResourceProps | undefined): Record<string, any> | undefined;
+/**
+ * ResourceSpec defines the desired state of Resource.
+ *
+ * @schema ResourceSpec
+ */
+export interface ResourceSpec {
+    /**
+     * A unique identifier to ensure the idempotency of the resource request. As a best practice, specify this token to ensure idempotency, so that Amazon Web Services Cloud Control API can accurately distinguish between request retries and new resource requests. You might retry a resource request to ensure that it was successfully received.
+     * A client token is valid for 36 hours once used. After that, a resource request with the same client token is treated as a new request.
+     * If you do not specify a client token, one is generated for inclusion in the request.
+     * For more information, see Ensuring resource operation requests are unique (https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations.html#resource-operations-idempotency) in the Amazon Web Services Cloud Control API User Guide.
+     *
+     * @schema ResourceSpec#clientToken
+     */
+    readonly clientToken?: string;
+    /**
+     * Structured data format representing the desired state of the resource, consisting of that resource's properties and their desired values.
+     * Cloud Control API currently supports JSON as a structured data format.
+     * Specify the desired state as one of the following:
+     * * A JSON blob
+     * * A local path containing the desired state in JSON data format
+     * For more information, see Composing the desired state of the resource (https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations-create.html#resource-operations-create-desiredstate) in the Amazon Web Services Cloud Control API User Guide.
+     * For more information about the properties of a specific resource, refer to the related topic for the resource in the Resource and property types reference (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) in the Amazon Web Services CloudFormation Users Guide.
+     *
+     * @schema ResourceSpec#desiredState
+     */
+    readonly desiredState: string;
+    /**
+     * The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) for Cloud Control API to use when performing this resource operation. The role specified must have the permissions required for this operation. The necessary permissions for each event handler are defined in the handlers (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-schema.html#schema-properties-handlers) section of the resource type definition schema (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-schema.html).
+     * If you do not specify a role, Cloud Control API uses a temporary session created using your Amazon Web Services user credentials.
+     * For more information, see Specifying credentials (https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations.html#resource-operations-permissions) in the Amazon Web Services Cloud Control API User Guide.
+     *
+     * @schema ResourceSpec#roleARN
+     */
+    readonly roleArn?: string;
+    /**
+     * The name of the resource type.
+     *
+     * @schema ResourceSpec#typeName
+     */
+    readonly typeName: string;
+    /**
+     * For private resource types, the type version to use in this resource operation. If you do not specify a resource version, CloudFormation uses the default version.
+     *
+     * @schema ResourceSpec#typeVersionID
+     */
+    readonly typeVersionId?: string;
+}
+/**
+ * Converts an object of type 'ResourceSpec' to JSON representation.
+ */
+export declare function toJson_ResourceSpec(obj: ResourceSpec | undefined): Record<string, any> | undefined;
+//# sourceMappingURL=cloudcontrol.services.k8s.aws.d.ts.map

package/lib/imports/cloudcontrol.services.k8s.aws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudcontrol.services.k8s.aws.d.ts","sourceRoot":"","sources":["../../src/imports/cloudcontrol.services.k8s.aws.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGvC;;;;GAIG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC;;OAEG;IACH,gBAAuB,GAAG,EAAE,gBAAgB,CAG1C;IAEF;;;;;;OAMG;WACW,QAAQ,CAAC,KAAK,GAAE,aAAkB,GAAG,GAAG;IAOtD;;;;;OAKG;gBACgB,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,GAAE,aAAkB;IAO1E;;OAEG;IACI,MAAM,IAAI,GAAG;CAQrB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAEtC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;CAE9B;AAED;;GAEG;AAEH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAQpG;AAGD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CAEjC;AAED;;GAEG;AAEH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAWlG"}

package/lib/imports/cloudcontrol.services.k8s.aws.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJson_ResourceSpec = exports.toJson_ResourceProps = exports.Resource = void 0;
+// generated by cdk8s
+const cdk8s_1 = require("cdk8s");
+/**
+ * Resource is the Schema for the Resources API
+ *
+ * @schema Resource
+ */
+class Resource extends cdk8s_1.ApiObject {
+    /**
+     * Defines a "Resource" API object
+     * @param scope the scope in which to define this object
+     * @param id a scope-local name for the object
+     * @param props initialization props
+     */
+    constructor(scope, id, props = {}) {
+        super(scope, id, {
+            ...Resource.GVK,
+            ...props,
+        });
+    }
+    /**
+     * Renders a Kubernetes manifest for "Resource".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props = {}) {
+        return {
+            ...Resource.GVK,
+            ...toJson_ResourceProps(props),
+        };
+    }
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson() {
+        const resolved = super.toJson();
+        return {
+            ...Resource.GVK,
+            ...toJson_ResourceProps(resolved),
+        };
+    }
+}
+exports.Resource = Resource;
+/**
+ * Returns the apiVersion and kind for "Resource"
+ */
+Resource.GVK = {
+    apiVersion: 'cloudcontrol.services.k8s.aws/v1alpha1',
+    kind: 'Resource',
+};
+/**
+ * Converts an object of type 'ResourceProps' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_ResourceProps(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'metadata': obj.metadata,
+        'spec': toJson_ResourceSpec(obj.spec),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_ResourceProps = toJson_ResourceProps;
+/**
+ * Converts an object of type 'ResourceSpec' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_ResourceSpec(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'clientToken': obj.clientToken,
+        'desiredState': obj.desiredState,
+        'roleARN': obj.roleArn,
+        'typeName': obj.typeName,
+        'typeVersionID': obj.typeVersionId,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_ResourceSpec = toJson_ResourceSpec;
+/* eslint-enable max-len, quote-props */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudcontrol.services.k8s.aws.js","sourceRoot":"","sources":["../../src/imports/cloudcontrol.services.k8s.aws.ts"],"names":[],"mappings":";;;AAAA,qBAAqB;AACrB,iCAAuE;AAIvE;;;;GAIG;AACH,MAAa,QAAS,SAAQ,iBAAS;IAuBrC;;;;;OAKG;IACH,YAAmB,KAAgB,EAAE,EAAU,EAAE,QAAuB,EAAE;QACxE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE;YACf,GAAG,QAAQ,CAAC,GAAG;YACf,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAzBD;;;;;;OAMG;IACI,MAAM,CAAC,QAAQ,CAAC,QAAuB,EAAE;QAC9C,OAAO;YACL,GAAG,QAAQ,CAAC,GAAG;YACf,GAAG,oBAAoB,CAAC,KAAK,CAAC;SAC/B,CAAC;IACJ,CAAC;IAeD;;OAEG;IACI,MAAM;QACX,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QAEhC,OAAO;YACL,GAAG,QAAQ,CAAC,GAAG;YACf,GAAG,oBAAoB,CAAC,QAAQ,CAAC;SAClC,CAAC;IACJ,CAAC;;AA9CH,4BA+CC;AA9CC;;GAEG;AACoB,YAAG,GAAqB;IAC7C,UAAU,EAAE,wCAAwC;IACpD,IAAI,EAAE,UAAU;CACjB,CAAC;AA8DJ;;GAEG;AACH,yCAAyC;AACzC,SAAgB,oBAAoB,CAAC,GAA8B;IACjE,IAAI,GAAG,KAAK,SAAS,EAAE;QAAE,OAAO,SAAS,CAAC;KAAE;IAC5C,MAAM,MAAM,GAAG;QACb,UAAU,EAAE,GAAG,CAAC,QAAQ;QACxB,MAAM,EAAE,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC;KACtC,CAAC;IACF,0BAA0B;IAC1B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;AAC1G,CAAC;AARD,oDAQC;AAyDD;;GAEG;AACH,yCAAyC;AACzC,SAAgB,mBAAmB,CAAC,GAA6B;IAC/D,IAAI,GAAG,KAAK,SAAS,EAAE;QAAE,OAAO,SAAS,CAAC;KAAE;IAC5C,MAAM,MAAM,GAAG;QACb,aAAa,EAAE,GAAG,CAAC,WAAW;QAC9B,cAAc,EAAE,GAAG,CAAC,YAAY;QAChC,SAAS,EAAE,GAAG,CAAC,OAAO;QACtB,UAAU,EAAE,GAAG,CAAC,QAAQ;QACxB,eAAe,EAAE,GAAG,CAAC,aAAa;KACnC,CAAC;IACF,0BAA0B;IAC1B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;AAC1G,CAAC;AAXD,kDAWC;AACD,wCAAwC","sourcesContent":["// generated by cdk8s\nimport { ApiObject, ApiObjectMetadata, GroupVersionKind } from 'cdk8s';\nimport { Construct } from 'constructs';\n\n\n/**\n * Resource is the Schema for the Resources API\n *\n * @schema Resource\n */\nexport class Resource extends ApiObject {\n  /**\n   * Returns the apiVersion and kind for \"Resource\"\n   */\n  public static readonly GVK: GroupVersionKind = {\n    apiVersion: 'cloudcontrol.services.k8s.aws/v1alpha1',\n    kind: 'Resource',\n  };\n\n  /**\n   * Renders a Kubernetes manifest for \"Resource\".\n   *\n   * This can be used to inline resource manifests inside other objects (e.g. as templates).\n   *\n   * @param props initialization props\n   */\n  public static manifest(props: ResourceProps = {}): any {\n    return {\n      ...Resource.GVK,\n      ...toJson_ResourceProps(props),\n    };\n  }\n\n  /**\n   * Defines a \"Resource\" API object\n   * @param scope the scope in which to define this object\n   * @param id a scope-local name for the object\n   * @param props initialization props\n   */\n  public constructor(scope: Construct, id: string, props: ResourceProps = {}) {\n    super(scope, id, {\n      ...Resource.GVK,\n      ...props,\n    });\n  }\n\n  /**\n   * Renders the object to Kubernetes JSON.\n   */\n  public toJson(): any {\n    const resolved = super.toJson();\n\n    return {\n      ...Resource.GVK,\n      ...toJson_ResourceProps(resolved),\n    };\n  }\n}\n\n/**\n * Resource is the Schema for the Resources API\n *\n * @schema Resource\n */\nexport interface ResourceProps {\n  /**\n   * @schema Resource#metadata\n   */\n  readonly metadata?: ApiObjectMetadata;\n\n  /**\n   * ResourceSpec defines the desired state of Resource.\n   *\n   * @schema Resource#spec\n   */\n  readonly spec?: ResourceSpec;\n\n}\n\n/**\n * Converts an object of type 'ResourceProps' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_ResourceProps(obj: ResourceProps | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'metadata': obj.metadata,\n    'spec': toJson_ResourceSpec(obj.spec),\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * ResourceSpec defines the desired state of Resource.\n *\n * @schema ResourceSpec\n */\nexport interface ResourceSpec {\n  /**\n   * A unique identifier to ensure the idempotency of the resource request. As a best practice, specify this token to ensure idempotency, so that Amazon Web Services Cloud Control API can accurately distinguish between request retries and new resource requests. You might retry a resource request to ensure that it was successfully received.\n   * A client token is valid for 36 hours once used. After that, a resource request with the same client token is treated as a new request.\n   * If you do not specify a client token, one is generated for inclusion in the request.\n   * For more information, see Ensuring resource operation requests are unique (https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations.html#resource-operations-idempotency) in the Amazon Web Services Cloud Control API User Guide.\n   *\n   * @schema ResourceSpec#clientToken\n   */\n  readonly clientToken?: string;\n\n  /**\n   * Structured data format representing the desired state of the resource, consisting of that resource's properties and their desired values.\n   * Cloud Control API currently supports JSON as a structured data format.\n   * Specify the desired state as one of the following:\n   * * A JSON blob\n   * * A local path containing the desired state in JSON data format\n   * For more information, see Composing the desired state of the resource (https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations-create.html#resource-operations-create-desiredstate) in the Amazon Web Services Cloud Control API User Guide.\n   * For more information about the properties of a specific resource, refer to the related topic for the resource in the Resource and property types reference (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) in the Amazon Web Services CloudFormation Users Guide.\n   *\n   * @schema ResourceSpec#desiredState\n   */\n  readonly desiredState: string;\n\n  /**\n   * The Amazon Resource Name (ARN) of the Identity and Access Management (IAM) for Cloud Control API to use when performing this resource operation. The role specified must have the permissions required for this operation. The necessary permissions for each event handler are defined in the handlers (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-schema.html#schema-properties-handlers) section of the resource type definition schema (https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/resource-type-schema.html).\n   * If you do not specify a role, Cloud Control API uses a temporary session created using your Amazon Web Services user credentials.\n   * For more information, see Specifying credentials (https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/resource-operations.html#resource-operations-permissions) in the Amazon Web Services Cloud Control API User Guide.\n   *\n   * @schema ResourceSpec#roleARN\n   */\n  readonly roleArn?: string;\n\n  /**\n   * The name of the resource type.\n   *\n   * @schema ResourceSpec#typeName\n   */\n  readonly typeName: string;\n\n  /**\n   * For private resource types, the type version to use in this resource operation. If you do not specify a resource version, CloudFormation uses the default version.\n   *\n   * @schema ResourceSpec#typeVersionID\n   */\n  readonly typeVersionId?: string;\n\n}\n\n/**\n * Converts an object of type 'ResourceSpec' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_ResourceSpec(obj: ResourceSpec | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'clientToken': obj.clientToken,\n    'desiredState': obj.desiredState,\n    'roleARN': obj.roleArn,\n    'typeName': obj.typeName,\n    'typeVersionID': obj.typeVersionId,\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n"]}