sst 1.16.0 → 2.0.0-rc.0

package/{dist/constructs → constructs}/App.js

@@ -1,5 +1,5 @@
 import path from "path";
-import fs from "fs-extra";
+import fs from "fs";
 import * as cdk from "aws-cdk-lib";
 import * as s3 from "aws-cdk-lib/aws-s3";
 import * as iam from "aws-cdk-lib/aws-iam";
@@ -8,12 +8,15 @@ import * as lambda from "aws-cdk-lib/aws-lambda";
 import { Stack } from "./Stack.js";
 import { isSSTConstruct, isStackConstruct, } from "./Construct.js";
 import { Function } from "./Function.js";
-import { bindType } from "./util/functionBinding.js";
+import { bindParameters, bindType } from "./util/functionBinding.js";
 import { stack } from "./FunctionalStack.js";
 import { createRequire } from "module";
 import { Auth } from "./Auth.js";
 import { useDeferredTasks } from "./deferred_task.js";
 import { AppContext } from "./context.js";
+import { useProject } from "../app.js";
+import { Logger } from "../logger.js";
+import { SiteEnv } from "../site-env.js";
 const require = createRequire(import.meta.url);
 function exitWithMessage(message) {
     console.error(message);
@@ -23,35 +26,85 @@ function exitWithMessage(message) {
  * The App construct extends cdk.App and is used internally by SST.
  */
 export class App extends cdk.App {
+    /**
+     * Whether or not the app is running locally under `sst start`
+     */
+    local = false;
+    /**
+     * Whether the app is running locally under start, deploy or remove
+     */
+    mode;
+    /**
+     * The name of your app, comes from the `name` in your `sst.json`
+     */
+    name;
+    /**
+     * The stage the app is being deployed to. If this is not specified as the --stage option, it'll default to the stage configured during the initial run of the SST CLI.
+     */
+    stage;
+    /**
+     * The region the app is being deployed to. If this is not specified as the --region option in the SST CLI, it'll default to the region in your sst.json.
+     */
+    region;
+    /**
+     * The AWS account the app is being deployed to. This comes from the IAM credentials being used to run the SST CLI.
+     */
+    account;
+    /** @internal */
+    debugBridge;
+    /** @internal */
+    debugEndpoint;
+    /** @internal */
+    debugBucketArn;
+    /** @internal */
+    debugBucketName;
+    /** @internal */
+    debugStartedAt;
+    /** @internal */
+    debugIncreaseTimeout;
+    /** @internal */
+    appPath;
+    /** @internal */
+    bootstrap;
+    /** @internal */
+    defaultFunctionProps;
+    _defaultRemovalPolicy;
+    /** @internal */
+    get defaultRemovalPolicy() {
+        return this._defaultRemovalPolicy;
+    }
+    /**
+     * Skip building Function code
+     * Note that on `sst remove`, we do not want to bundle the Lambda functions.
+     *      CDK disables bundling (ie. zipping) for `cdk destroy` command.
+     *      But SST runs `cdk synth` first then manually remove each stack. Hence
+     *      we cannot rely on CDK to disable bundling, and we disable it manually.
+     *      This allows us to disable BOTH building and bundling, where as CDK
+     *      would only disable the latter. For example, `cdk destroy` still trys
+     *      to install Python dependencies in Docker.
+     *
+     * @internal
+     */
+    skipBuild;
     /**
      * @internal
      */
     constructor(deployProps, props = {}) {
         super(props);
-        /**
-         * Whether or not the app is running locally under `sst start`
-         */
-        this.local = false;
-        /**
-         * A list of Lambda functions in the app
-         */
-        this.lambdaHandlers = [];
-        this.siteEnvironments = [];
         AppContext.provide(this);
+        SiteEnv.reset();
         this.bootstrap = deployProps.bootstrap;
         this.appPath = process.cwd();
         this.mode = deployProps.mode;
-        this.local = this.mode === "start";
+        this.local = this.mode === "dev";
         this.stage = deployProps.stage || "dev";
         this.name = deployProps.name || "my-app";
         this.region =
             deployProps.region || process.env.CDK_DEFAULT_REGION || "us-east-1";
         this.account =
             deployProps.account || process.env.CDK_DEFAULT_ACCOUNT || "my-account";
-        this.buildDir = deployProps.buildDir || ".build";
         this.skipBuild = deployProps.skipBuild || false;
         this.defaultFunctionProps = [];
-        this.synthCallback = deployProps.synthCallback;
         if (deployProps.debugEndpoint) {
             this.local = true;
             this.debugEndpoint = deployProps.debugEndpoint;
@@ -64,10 +117,6 @@ export class App extends cdk.App {
             }
         }
     }
-    /** @internal */
-    get defaultRemovalPolicy() {
-        return this._defaultRemovalPolicy;
-    }
     /**
      * Use this method to prefix resource names in your stacks to make sure they don't thrash when deployed to different stages in the same AWS account. This method will prefix a given resource name with the stage and app name. Using the format `${stage}-${name}-${logicalName}`.
      * @example
@@ -107,8 +156,6 @@ export class App extends cdk.App {
      * ```
      */
     setDefaultFunctionProps(props) {
-        if (this.lambdaHandlers.length > 0)
-            throw new Error("Cannot call 'setDefaultFunctionProps' after a stack with functions has been created. Please use 'addDefaultFunctionEnv' or 'addDefaultFunctionPermissions' to add more default properties. Read more about this change here: https://docs.sst.dev/constructs/App#upgrading-to-v0420");
         this.defaultFunctionProps.push(props);
     }
     /**
@@ -180,6 +227,7 @@ export class App extends cdk.App {
         this.ensureUniqueConstructIds();
         this.codegenTypes();
         this.buildConstructsMetadata();
+        this.createBindingSsmParameters();
         this.removeGovCloudUnsupportedResourceProperties();
         for (const child of this.node.children) {
             if (isStackConstruct(child)) {
@@ -198,35 +246,39 @@ export class App extends cdk.App {
             }
         }
         const cloudAssembly = super.synth(options);
-        // Run callback after synth has finished
-        if (this.synthCallback) {
-            this.synthCallback(this.lambdaHandlers, this.siteEnvironments);
-        }
         return cloudAssembly;
     }
-    async runDeferredBuilds() {
+    async finish() {
         await useDeferredTasks().run();
     }
     isRunningSSTTest() {
         // Check the env var set inside test/setup-tests.js
         return process.env.SST_RESOURCES_TESTS === "enabled";
     }
-    registerLambdaHandler(handler) {
-        this.lambdaHandlers.push(handler);
-    }
-    registerSiteEnvironment(environment) {
-        this.siteEnvironments.push(environment);
-    }
     getInputFilesFromEsbuildMetafile(file) {
         let metaJson;
         try {
-            metaJson = fs.readJsonSync(file);
+            metaJson = JSON.parse(fs.readFileSync(file).toString());
         }
         catch (e) {
             exitWithMessage("There was a problem reading the esbuild metafile.");
         }
         return Object.keys(metaJson.inputs).map((input) => path.resolve(input));
     }
+    createBindingSsmParameters() {
+        class CreateSsmParameters {
+            visit(c) {
+                if (!isSSTConstruct(c)) {
+                    return;
+                }
+                if (c instanceof Function && c._disableBind) {
+                    return;
+                }
+                bindParameters(c);
+            }
+        }
+        cdk.Aspects.of(this).add(new CreateSsmParameters());
+    }
     buildConstructsMetadata() {
         const constructs = this.buildConstructsMetadata_collectConstructs(this);
         const byStack = {};
@@ -390,57 +442,25 @@ export class App extends cdk.App {
         cdk.Aspects.of(this).add(new EnsureUniqueConstructIds());
     }
     codegenTypes() {
-        // Find the node_modules folder to create the type files in
-        const nodeModulesPath = this.codegenFindNodeModulesPath();
-        if (!nodeModulesPath) {
-            return;
-        }
-        const typesPath = path.resolve(nodeModulesPath, "node_modules", "@types", "serverless-stack__node");
-        this.codegenCreateIndexType(typesPath);
-        this.codegenCreateConstructTypes(typesPath);
-    }
-    codegenFindNodeModulesPath() {
-        const rootPath = path.parse(process.cwd()).root;
-        let directory = this.appPath;
-        while (directory !== rootPath) {
-            const checkPath = path.resolve(directory, "node_modules", "@serverless-stack", "node");
-            if (fs.existsSync(checkPath)) {
-                return directory;
-            }
-            directory = path.dirname(directory);
-        }
-    }
-    codegenCreateIndexType(typesPath) {
-        fs.removeSync(typesPath);
+        const project = useProject();
+        const typesPath = path.resolve(project.paths.out, "types");
+        Logger.debug(`Generating types in ${typesPath}`);
+        fs.rmSync(typesPath, {
+            recursive: true,
+            force: true,
+        });
         fs.mkdirSync(typesPath, {
             recursive: true,
         });
-        fs.writeFileSync(`${typesPath}/index.d.ts`, `
-import "@serverless-stack/node/config";
-declare module "@serverless-stack/node/config" {
-  export interface ConfigTypes {
-    APP: string;
-    STAGE: string;
-  }
-}`);
-    }
-    codegenCreateConstructTypes(typesPath) {
-        //export function codegenTypes(typesPath: string) {
-        //  fs.appendFileSync(`${typesPath}/index.d.ts`, `export * from "./config";`);
-        //  fs.writeFileSync(`${typesPath}/config.d.ts`, `
-        //    import "@serverless-stack/node/config";
-        //    declare module "@serverless-stack/node/config" {
-        //      export interface ConfigType {
-        //        ${[
-        //      "APP",
-        //      "STAGE",
-        //      ...Parameter.getAllNames(),
-        //      ...Secret.getAllNames()
-        //    ].map((p) => `${p}: string;`).join("\n")}
-        //      }
-        //    }
-        //  `);
-        //}
+        fs.writeFileSync(`${typesPath}/index.ts`, [
+            `import "sst/node/config";`,
+            `declare module "sst/node/config" {`,
+            `  export interface ConfigTypes {`,
+            `    APP: string;`,
+            `    STAGE: string;`,
+            `  }`,
+            `}`,
+        ].join("\n"));
         class CodegenTypes {
             visit(c) {
                 if (!isSSTConstruct(c)) {
@@ -455,26 +475,26 @@ declare module "@serverless-stack/node/config" {
                 }
                 const className = c.constructor.name;
                 const id = c.id;
-                fs.appendFileSync(`${typesPath}/index.d.ts`, `export * from "./${className}-${id}";`);
                 // Case 1: variable does not have properties, ie. Secrets and Parameters
-                const typeContent = binding.variables[0] === "."
-                    ? `
-import "@serverless-stack/node/${binding.clientPackage}";
-declare module "@serverless-stack/node/${binding.clientPackage}" {
-  export interface ${className}Resources {
-    "${id}": string;
-  }
-}`
-                    : `
-import "@serverless-stack/node/${binding.clientPackage}";
-declare module "@serverless-stack/node/${binding.clientPackage}" {
-  export interface ${className}Resources {
-    "${id}": {
-      ${binding.variables.map((p) => `${p}: string;`).join("\n")}
-    }
-  }
-}`;
-                fs.writeFileSync(`${typesPath}/${className}-${id}.d.ts`, typeContent);
+                fs.writeFileSync(`${typesPath}/${className}-${id}.ts`, (binding.variables[0] === "."
+                    ? [
+                        `import "sst/node/${binding.clientPackage}";`,
+                        `declare module "sst/node/${binding.clientPackage}" {`,
+                        `  export interface ${className}Resources {`,
+                        `    "${id}": string;`,
+                        `  }`,
+                        `}`,
+                    ]
+                    : [
+                        `import "sst/node/${binding.clientPackage}";`,
+                        `declare module "sst/node/${binding.clientPackage}" {`,
+                        `  export interface ${className}Resources {`,
+                        `    "${id}": {`,
+                        ...binding.variables.map((p) => `      ${p}: string;`),
+                        `    }`,
+                        `  }`,
+                        `}`,
+                    ]).join("\n"));
             }
         }
         cdk.Aspects.of(this).add(new CodegenTypes());

package/{dist/constructs → constructs}/AppSyncApi.d.ts

@@ -246,7 +246,7 @@ export interface AppSyncApiProps {
      * });
      * ```
      */
-    schema?: string | string[];
+    schema: string | string[];
     /**
      * Specify a custom domain to use in addition to the automatically generated one. SST currently supports domains that are configured using [Route 53](https://aws.amazon.com/route53/)
      *
@@ -331,7 +331,7 @@ export interface AppSyncApiProps {
         graphqlApi?: appsync.IGraphqlApi | AppSyncApiCdkGraphqlProps;
     };
 }
-export interface AppSyncApiCdkGraphqlProps extends Omit<appsync.GraphqlApiProps, "name"> {
+export interface AppSyncApiCdkGraphqlProps extends Omit<appsync.GraphqlApiProps, "name" | "schema"> {
     name?: string;
 }
 /**
@@ -379,7 +379,7 @@ export declare class AppSyncApi extends Construct implements SSTConstruct {
     private readonly resolversByResKey;
     private readonly bindingForAllFunctions;
     private readonly permissionsAttachedForAllFunctions;
-    constructor(scope: Construct, id: string, props?: AppSyncApiProps);
+    constructor(scope: Construct, id: string, props: AppSyncApiProps);
     /**
      * The Id of the internally created AppSync GraphQL API.
      */

package/{dist/constructs → constructs}/AppSyncApi.js

@@ -1,4 +1,5 @@
-import fs from "fs-extra";
+import path from "path";
+import fs from "fs";
 export async function weakImport(pkg) {
     try {
         return await import(pkg);
@@ -14,7 +15,7 @@ import * as appsync from "@aws-cdk/aws-appsync-alpha";
 import * as appSyncApiDomain from "./util/appSyncApiDomain.js";
 import { getFunctionRef, isCDKConstruct } from "./Construct.js";
 import { Function as Fn, } from "./Function.js";
-import { State } from "@serverless-stack/core";
+import { useProject } from "../app.js";
 /////////////////////
 // Construct
 /////////////////////
@@ -43,16 +44,21 @@ import { State } from "@serverless-stack/core";
  * ```
  */
 export class AppSyncApi extends Construct {
+    id;
+    cdk;
+    props;
+    _customDomainUrl;
+    _cfnDomainName;
+    functionsByDsKey = {};
+    dataSourcesByDsKey = {};
+    dsKeysByResKey = {};
+    resolversByResKey = {};
+    bindingForAllFunctions = [];
+    permissionsAttachedForAllFunctions = [];
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.functionsByDsKey = {};
-        this.dataSourcesByDsKey = {};
-        this.dsKeysByResKey = {};
-        this.resolversByResKey = {};
-        this.bindingForAllFunctions = [];
-        this.permissionsAttachedForAllFunctions = [];
         this.id = id;
-        this.props = props || {};
+        this.props = props;
         this.cdk = {};
         this.createGraphApi();
         // Configure data sources
@@ -273,18 +279,19 @@ export class AppSyncApi extends Construct {
             // build schema
             let mainSchema;
             if (typeof schema === "string") {
-                mainSchema = appsync.Schema.fromAsset(schema);
+                mainSchema = appsync.SchemaFile.fromAsset(schema);
             }
-            else if (Array.isArray(schema)) {
-                if (schema.length > 0) {
-                    // merge schema files
-                    const mergedSchema = mergeTypeDefs(schema
-                        .map((file) => fs.readFileSync(file).toString())
-                        .map(buildSchema));
-                    const filePath = State.resolve(app.appPath, `appsyncapi-${id}-${this.node.addr}.graphql`);
-                    fs.writeFileSync(filePath, print(mergedSchema));
-                    mainSchema = appsync.Schema.fromAsset(filePath);
+            else {
+                if (schema.length === 0) {
+                    throw new Error("Invalid schema. At least one schema file must be provided");
                 }
+                // merge schema files
+                const mergedSchema = mergeTypeDefs(schema
+                    .map((file) => fs.readFileSync(file).toString())
+                    .map(buildSchema));
+                const filePath = path.join(useProject().paths.out, `appsyncapi-${id}-${this.node.addr}.graphql`);
+                fs.writeFileSync(filePath, print(mergedSchema));
+                mainSchema = appsync.SchemaFile.fromAsset(filePath);
             }
             // build domain
             const domainData = appSyncApiDomain.buildCustomDomainData(this, customDomain);
@@ -448,7 +455,7 @@ export class AppSyncApi extends Construct {
         ///////////////////
         // Create resolver
         ///////////////////
-        const resolver = this.cdk.graphqlApi.createResolver({
+        const resolver = this.cdk.graphqlApi.createResolver(`${typeName}${fieldName}Resolver`, {
             dataSource,
             typeName,
             fieldName,

package/constructs/AstroSite.d.ts

@@ -0,0 +1,25 @@
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import { SsrSite } from "./SsrSite.js";
+import { EdgeFunction } from "./EdgeFunction.js";
+/**
+ * The `AstroSite` construct is a higher level CDK construct that makes it easy to create a Astro app.
+ * @example
+ * Deploys a Astro app in the `my-astro-app` directory.
+ *
+ * ```js
+ * new AstroSite(stack, "web", {
+ *   path: "my-astro-app/",
+ * });
+ * ```
+ */
+export declare class AstroSite extends SsrSite {
+    protected initBuildConfig(): {
+        serverBuildOutputFile: string;
+        clientBuildOutputDir: string;
+        clientBuildVersionedSubDir: string;
+        siteStub: string;
+    };
+    protected validateBuildOutput(): void;
+    protected createFunctionForRegional(): lambda.Function;
+    protected createFunctionForEdge(): EdgeFunction;
+}

package/constructs/AstroSite.js

@@ -0,0 +1,111 @@
+import fs from "fs";
+import url from "url";
+import path from "path";
+import * as esbuild from "esbuild";
+import { SsrSite } from "./SsrSite.js";
+import { Function } from "./Function.js";
+import { EdgeFunction } from "./EdgeFunction.js";
+const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+/**
+ * The `AstroSite` construct is a higher level CDK construct that makes it easy to create a Astro app.
+ * @example
+ * Deploys a Astro app in the `my-astro-app` directory.
+ *
+ * ```js
+ * new AstroSite(stack, "web", {
+ *   path: "my-astro-app/",
+ * });
+ * ```
+ */
+export class AstroSite extends SsrSite {
+    initBuildConfig() {
+        return {
+            serverBuildOutputFile: "dist/server/entry.mjs",
+            clientBuildOutputDir: "dist/client",
+            clientBuildVersionedSubDir: "assets",
+            siteStub: path.resolve(__dirname, "../support/astro-site-html-stub"),
+        };
+    }
+    validateBuildOutput() {
+        const serverDir = path.join(this.props.path, "dist/server");
+        const clientDir = path.join(this.props.path, "dist/client");
+        if (!fs.existsSync(serverDir) || !fs.existsSync(clientDir)) {
+            throw new Error(`Build output inside "dist/" does not contain the "server" and "client" folders. Make sure Server-side Rendering (SSR) is enabled in your Astro app. If you are looking to deploy the Astro app as a static site, please use the StaticSite construct — https://docs.sst.dev/constructs/StaticSite`);
+        }
+        super.validateBuildOutput();
+    }
+    createFunctionForRegional() {
+        const { defaults, environment } = this.props;
+        // Bundle code
+        const handler = this.isPlaceholder
+            ? path.resolve(__dirname, "../support/ssr-site-function-stub/index.handler")
+            : path.join(this.props.path, "dist", "server", "entry.handler");
+        // Create function
+        const fn = new Function(this, `ServerFunction`, {
+            description: "Server handler",
+            handler,
+            logRetention: "three_days",
+            runtime: "nodejs16.x",
+            memorySize: defaults?.function?.memorySize || "512 MB",
+            timeout: defaults?.function?.timeout || "10 seconds",
+            nodejs: {
+                format: "esm",
+            },
+            enableLiveDev: false,
+            environment,
+        });
+        fn._disableBind = true;
+        return fn;
+    }
+    createFunctionForEdge() {
+        const { defaults, environment } = this.props;
+        // Bundle code
+        let bundlePath;
+        let handler;
+        if (this.isPlaceholder) {
+            bundlePath = path.resolve(__dirname, "../support/ssr-site-function-stub");
+            handler = "index.handler";
+        }
+        else {
+            // Create a directory that we will use to create the bundled version
+            // of the "core server build" along with our custom Lamba server handler.
+            const outputPath = path.resolve(path.join(this.sstBuildDir, `AstroSiteFunction-${this.node.id}-${this.node.addr}`));
+            const result = esbuild.buildSync({
+                entryPoints: [path.join(this.props.path, this.buildConfig.serverBuildOutputFile)],
+                target: "esnext",
+                format: "esm",
+                platform: "node",
+                metafile: true,
+                bundle: true,
+                write: true,
+                allowOverwrite: true,
+                outfile: path.join(outputPath, "entry.mjs"),
+                banner: {
+                    js: [
+                        `import { createRequire as topLevelCreateRequire } from 'module';`,
+                        `const require = topLevelCreateRequire(import.meta.url);`,
+                    ].join(""),
+                },
+            });
+            if (result.errors.length > 0) {
+                result.errors.forEach((error) => console.error(error));
+                throw new Error(`There was a problem bundling the function code for the ${this.id} AstroSite.`);
+            }
+            // Create package.json
+            fs.writeFileSync(path.join(outputPath, "package.json"), `{"type":"module"}`);
+            bundlePath = outputPath;
+            handler = "entry.handler";
+        }
+        // Create function
+        return new EdgeFunction(this, `Server`, {
+            scopeOverride: this,
+            bundlePath,
+            handler,
+            timeout: defaults?.function?.timeout,
+            memory: defaults?.function?.memorySize,
+            permissions: defaults?.function?.permissions,
+            environment,
+            format: "esm",
+        });
+    }
+}

package/constructs/AstroSite.tsdoc.d.ts

@@ -0,0 +1,2 @@
+export * from "./AstroSite.js";
+export * from "./SsrSite.js";

package/constructs/AstroSite.tsdoc.js

@@ -0,0 +1,2 @@
+export * from "./AstroSite.js";
+export * from "./SsrSite.js";

package/{dist/constructs → constructs}/Auth.d.ts

@@ -1,6 +1,6 @@
 import { Construct } from "constructs";
 import { Api } from "./Api.js";
-import { FunctionDefinition } from "./Function";
+import { FunctionDefinition } from "./Function.js";
 import { SSTConstruct } from "./Construct.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
 export interface AuthProps {

package/{dist/constructs → constructs}/Auth.js

@@ -1,7 +1,7 @@
 import * as ssm from "aws-cdk-lib/aws-ssm";
 import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { Construct } from "constructs";
-import { Stack } from "./index.js";
+import { Stack } from "./Stack.js";
 import { ENVIRONMENT_PLACEHOLDER, getEnvironmentKey, getParameterPath } from "./util/functionBinding.js";
 import { CustomResource } from "aws-cdk-lib";
 const PUBLIC_KEY_PROP = "publicKey";
@@ -18,9 +18,13 @@ const PREFIX_PROP = "prefix";
  * })
  */
 export class Auth extends Construct {
+    id;
+    authenticator;
+    apis = new Set();
+    /** @internal */
+    static list = new Set();
     constructor(scope, id, props) {
         super(scope, props.cdk?.id || id);
-        this.apis = new Set();
         if (!props.authenticator ||
             "defaults" in props ||
             "login" in props ||
@@ -151,5 +155,3 @@ export class Auth extends Construct {
         }
     }
 }
-/** @internal */
-Auth.list = new Set();

package/{dist/constructs → constructs}/Bucket.js

@@ -21,11 +21,14 @@ import { toCdkDuration } from "./util/duration.js";
  * ```
  */
 export class Bucket extends Construct {
+    id;
+    cdk;
+    notifications = {};
+    bindingForAllNotifications = [];
+    permissionsAttachedForAllNotifications = [];
+    props;
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.notifications = {};
-        this.bindingForAllNotifications = [];
-        this.permissionsAttachedForAllNotifications = [];
         this.id = id;
         this.props = props || {};
         this.cdk = {};

package/{dist/constructs → constructs}/Cognito.js

@@ -34,9 +34,12 @@ const CognitoUserPoolTriggerOperationMapping = {
  * ```
  */
 export class Cognito extends Construct {
+    id;
+    cdk;
+    functions = {};
+    props;
     constructor(scope, id, props) {
         super(scope, props?.cdk?.id || id);
-        this.functions = {};
         this.id = id;
         this.props = props || {};
         this.cdk = {};