appsync - apiKeyConfig expires outputting incorrect format

[m0rph13]

When specifying the attribute "expires" for apiKeyConfig, the rendered cloudformation gets a value of null.

Reproduction Steps

const api = new GraphQLApi(this, 'api', {
            name: getResourceName('graphql'),
            authorizationConfig: {
                defaultAuthorization: {
                    authorizationType: AuthorizationType.API_KEY,
                    apiKeyConfig: {
                        name: "api-key",
                        description: "api-key",
                        expires: "1614164998"
                    }
                },    
            schemaDefinitionFile: 'schema.graphql',
        });

Error Log

Synth gives:

 apiapikeyApiKeyXXXXXX:
    Type: AWS::AppSync::ApiKey
    Properties:
      ApiId:
        Fn::GetAtt:
          - apiCXXXXXX
          - ApiId
      Description: api-key
      Expires: null

Environment

• CLI Version : 1.46.0
• Framework Version: 1.46.0
• Node.js Version: v12.16.1
• OS : OSX
• Language (Version): 3.8.3

Other

---

This is 🐛 Bug Report

[civilizeddev]

According to the definition:

export interface ApiKeyConfig {
  ...

  /**
   * The time from creation time after which the API key expires, using RFC3339 representation.
   * It must be a minimum of 1 day and a maximum of 365 days from date of creation.
   * Rounded down to the nearest hour.
   * @default - 7 days from creation time
   */
  readonly expires?: string;
}

Workaround

You should set expires like 2020-12-31T23:30:00Z

Use new Date(...).toISOString() or any other date/time library.

Proposed solution

But in fact, it is also prone to errors and needs to be changed in a different way.

export interface ApiKeyConfig {
  ...

  /**
   * The duration from creation time after which the API key expires.
   * It must be a minimum of 1 day and a maximum of 365 days from date of creation.
   * Rounded down to the nearest hour.
   * @default - cdk.Duration.days(7)
   */
  readonly expiresAfter?: cdk.Duration;
}

Any good idea?

[civilizeddev]

What about using kind of Expires?

AS-IS

{
  ...,
  expires: '2020-12-31T23:30:00Z'
}

TO-BE

• expires: Expires.atDate(new Date('2020-12-31T23:30:00Z'))
• expires: Expires.after(cdk.Duration.months(6))
• expires: Expires.fromTimestamp(1614164998000)
• expires: Expires.fromString('2020-12-31T23:30:00Z')

References

I hope the things below would be promoted to @aws-cdk/core, as well as Duration

@nija-at @jogold

Expires

aws-cdk/packages/@aws-cdk/aws-s3-deployment/lib/bucket-deployment.ts

Lines 318 to 344 in 254556d

	/**
	* Used for HTTP expires header, which influences downstream caches. Does NOT influence deletion of the object.
	* @see https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html#SysMetadata
	*/
	export class Expires {
	/**
	* Expire at the specified date
	* @param d date to expire at
	*/
	public static atDate(d: Date) { return new Expires(d.toUTCString()); }
	/**
	* Expire at the specified timestamp
	* @param t timestamp in unix milliseconds
	*/
	public static atTimestamp(t: number) { return Expires.atDate(new Date(t)); }
	/**
	* Expire once the specified duration has passed since deployment time
	* @param t the duration to wait before expiring
	*/
	public static after(t: cdk.Duration) { return Expires.atDate(new Date(now + t.toMilliseconds())); }
	public static fromString(s: string) { return new Expires(s); }
	private constructor(public readonly value: any) {}
	}

Schedule

aws-cdk/packages/@aws-cdk/aws-applicationautoscaling/lib/schedule.ts

Lines 3 to 64 in 254556d

	/**
	* Schedule for scheduled scaling actions
	*/
	export abstract class Schedule {
	/**
	* Construct a schedule from a literal schedule expression
	*
	* @param expression The expression to use. Must be in a format that Application AutoScaling will recognize
	*/
	public static expression(expression: string): Schedule {
	return new LiteralSchedule(expression);
	}
	/**
	* Construct a schedule from an interval and a time unit
	*/
	public static rate(duration: Duration): Schedule {
	if (duration.toSeconds() === 0) {
	throw new Error('Duration cannot be 0');
	}
	let rate = maybeRate(duration.toDays({ integral: false }), 'day');
	if (rate === undefined) { rate = maybeRate(duration.toHours({ integral: false }), 'hour'); }
	if (rate === undefined) { rate = makeRate(duration.toMinutes({ integral: true }), 'minute'); }
	return new LiteralSchedule(rate);
	}
	/**
	* Construct a Schedule from a moment in time
	*/
	public static at(moment: Date): Schedule {
	return new LiteralSchedule(`at(${formatISO(moment)})`);
	}
	/**
	* Create a schedule from a set of cron fields
	*/
	public static cron(options: CronOptions): Schedule {
	if (options.weekDay !== undefined && options.day !== undefined) {
	throw new Error('Cannot supply both \'day\' and \'weekDay\', use at most one');
	}
	const minute = fallback(options.minute, '*');
	const hour = fallback(options.hour, '*');
	const month = fallback(options.month, '*');
	const year = fallback(options.year, '*');
	// Weekday defaults to '?' if not supplied. If it is supplied, day must become '?'
	const day = fallback(options.day, options.weekDay !== undefined ? '?' : '*');
	const weekDay = fallback(options.weekDay, '?');
	return new LiteralSchedule(`cron(${minute} ${hour} ${day} ${month} ${weekDay} ${year})`);
	}
	/**
	* Retrieve the expression for this schedule
	*/
	public abstract readonly expressionString: string;
	protected constructor() {
	}
	}