@kensio/yulin 1.21.21 → 1.21.22

package/dist/service/scheduler/schedule/sim-scheduler-schedule.d.ts

@@ -21,6 +21,8 @@ interface SimSchedulerScheduleProperties {
     readonly state: SimSchedulerScheduleState;
     readonly actionAfterCompletion: SimSchedulerActionAfterCompletion;
     readonly description?: string | undefined;
+    /** The timezone the request named, which a describe reports back. */
+    readonly timeZone?: string | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -51,6 +53,13 @@ export declare class SimSchedulerSchedule {
     readonly target: SimSchedulerTarget;
     readonly actionAfterCompletion: SimSchedulerActionAfterCompletion;
     readonly description: string | undefined;
+    /**
+     * The timezone the schedule was created with, if it named one.
+     *
+     * A schedule created without one runs in UTC, and reports no timezone rather
+     * than reporting the one it fell back to.
+     */
+    readonly timeZone: string | undefined;
     readonly creationDate: Date;
     /**
      * When this schedule falls due, which is read as simulated time advances.

package/dist/service/scheduler/schedule/sim-scheduler-schedule.js

@@ -28,6 +28,13 @@ export class SimSchedulerSchedule {
     target;
     actionAfterCompletion;
     description;
+    /**
+     * The timezone the schedule was created with, if it named one.
+     *
+     * A schedule created without one runs in UTC, and reports no timezone rather
+     * than reporting the one it fell back to.
+     */
+    timeZone;
     creationDate;
     /**
      * When this schedule falls due, which is read as simulated time advances.
@@ -45,6 +52,7 @@ export class SimSchedulerSchedule {
         this.target = properties.target;
         this.actionAfterCompletion = properties.actionAfterCompletion;
         this.description = properties.description;
+        this.timeZone = properties.timeZone;
         this.creationDate = properties.createdAt;
         this.modified = properties.createdAt;
         this.held = properties.state;

package/dist/util/schedule/at/sim-at-expression.d.ts

@@ -1,3 +1,4 @@
+import type { SimScheduleZone } from "../sim-schedule-zone.js";
 /**
  * One `at()` expression: a single instant, and never another.
  *
@@ -12,7 +13,7 @@ export declare class SimAtExpression {
     /**
      * Read the instant inside an `at(...)`.
      */
-    static of(source: string): SimAtExpression;
+    static of(source: string, zone: SimScheduleZone): SimAtExpression;
     /**
      * The instant this expression names, once, and nothing after that.
      *

package/dist/util/schedule/at/sim-at-expression.js

@@ -7,6 +7,7 @@ import { SimScheduleExpressionError } from "../sim-schedule.error.js";
  * schedule rather than part of the expression, which is why one written here
  * would be ambiguous rather than helpful.
  */
+const millisecondsPerSecond = 1000;
 const atInstant = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2})$/u;
 /**
  * One `at()` expression: a single instant, and never another.
@@ -25,7 +26,7 @@ export class SimAtExpression {
     /**
      * Read the instant inside an `at(...)`.
      */
-    static of(source) {
+    static of(source, zone) {
         const read = atInstant.exec(source.trim())?.groups;
         if (read === undefined) {
             throw new SimScheduleExpressionError(`an at expression is an instant written 'yyyy-mm-ddThh:mm:ss', with ` +
@@ -37,11 +38,14 @@ export class SimAtExpression {
         // JavaScript rolls an impossible date over rather than refusing it, so the
         // thirtieth of February quietly becomes the second of March and half past
         // twenty-five becomes tomorrow morning. Writing the instant back out is
-        // what catches every one of those in one comparison.
+        // what catches every one of those in one comparison. The calendar is read
+        // in UTC for this, since which instant the wall-clock time is depends on
+        // the zone and whether it is a real time of day does not.
         if (!at.toISOString().startsWith(written)) {
             throw new SimScheduleExpressionError(`an at expression names a real instant, and '${source}' is not one`);
         }
-        return new this(source, at);
+        const minuteStart = zone.instantOf(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute));
+        return new this(source, new Date(minuteStart + Number(second) * millisecondsPerSecond));
     }
     /**
      * The instant this expression names, once, and nothing after that.

package/dist/util/schedule/cron/sim-cron-expression.d.ts

@@ -1,13 +1,16 @@
+import type { SimScheduleZone } from "../sim-schedule-zone.js";
 import type { SimCronFieldSpec } from "./sim-cron-field-spec.js";
 /**
  * One cron expression, read into the instants it falls due at.
  *
- * Everything is read in UTC. AWS runs scheduled rules in UTC and offers a
- * timezone as a separate setting, so a local timezone never enters into this.
+ * The fields name a wall-clock time, and the schedule's zone is what says which
+ * instants those are. An EventBridge rule has no timezone setting and gets the
+ * UTC zone, which reads exactly as the UTC calendar does.
  */
 export declare class SimCronExpression {
     readonly source: string;
     private readonly fields;
+    private readonly zone;
     private constructor();
     /**
      * Read a cron expression against a dialect's fields.
@@ -16,7 +19,7 @@ export declare class SimCronExpression {
      * is refused naming the form expected rather than read as though the missing
      * one were at the end.
      */
-    static of(specs: readonly SimCronFieldSpec[], source: string): SimCronExpression;
+    static of(specs: readonly SimCronFieldSpec[], source: string, zone: SimScheduleZone): SimCronExpression;
     /**
      * The next instant this expression falls due after an instant.
      *

package/dist/util/schedule/cron/sim-cron-expression.js

@@ -17,15 +17,18 @@ function startOfNextMinute(instant) {
 /**
  * One cron expression, read into the instants it falls due at.
  *
- * Everything is read in UTC. AWS runs scheduled rules in UTC and offers a
- * timezone as a separate setting, so a local timezone never enters into this.
+ * The fields name a wall-clock time, and the schedule's zone is what says which
+ * instants those are. An EventBridge rule has no timezone setting and gets the
+ * UTC zone, which reads exactly as the UTC calendar does.
  */
 export class SimCronExpression {
     source;
     fields;
-    constructor(source, fields) {
+    zone;
+    constructor(source, fields, zone) {
         this.source = source;
         this.fields = fields;
+        this.zone = zone;
     }
     /**
      * Read a cron expression against a dialect's fields.
@@ -34,14 +37,14 @@ export class SimCronExpression {
      * is refused naming the form expected rather than read as though the missing
      * one were at the end.
      */
-    static of(specs, source) {
+    static of(specs, source, zone) {
         const written = source.trim().split(whitespace);
         if (written.length !== specs.length) {
             throw new SimScheduleExpressionError(`a cron expression has ${String(specs.length)} fields separated by ` +
                 `spaces, ${specs.map((spec) => spec.name).join(" ")}, and this one ` +
                 `has ${String(written.length)}`);
         }
-        return new this(source, readFields(specs, written));
+        return new this(source, readFields(specs, written), zone);
     }
     /**
      * The next instant this expression falls due after an instant.
@@ -50,7 +53,7 @@ export class SimCronExpression {
      * has, since a cron expression naming only years in the past falls due never.
      */
     nextAfter(instant) {
-        const end = Date.UTC(this.fields.year.maximum + 1, 0, 1);
+        const end = this.zone.instantOf(this.fields.year.maximum + 1, 0, 1);
         let candidate = startOfNextMinute(instant);
         while (candidate < end) {
             const skipTo = this.skipUnmatched(candidate);
@@ -71,27 +74,27 @@ export class SimCronExpression {
      * steps rather than the million minutes they hold.
      */
     skipUnmatched(at) {
-        const date = new Date(at);
-        const year = date.getUTCFullYear();
+        const read = this.zone.partsAt(at);
+        const { year, month, day, hour } = read;
         if (!this.fields.year.allows(year)) {
-            return Date.UTC(year + 1, 0, 1);
+            return this.zone.instantOf(year + 1, 0, 1);
         }
-        const month = date.getUTCMonth();
         if (!this.fields.month.allows(month + 1)) {
-            return Date.UTC(year, month + 1, 1);
+            return this.zone.instantOf(year, month + 1, 1);
         }
-        const day = date.getUTCDate();
-        if (!this.allowsDay(date)) {
-            return Date.UTC(year, month, day + 1);
+        if (!this.allowsDay(read)) {
+            return this.zone.instantOf(year, month, day + 1);
         }
-        const hour = date.getUTCHours();
         if (!this.fields.hours.allows(hour)) {
-            return Date.UTC(year, month, day, hour + 1);
+            return this.zone.instantOf(year, month, day, hour + 1);
         }
-        if (!this.fields.minutes.allows(date.getUTCMinutes())) {
+        if (!this.fields.minutes.allows(read.minute)) {
             return at + millisecondsPerMinute;
         }
-        return undefined;
+        // The second of a repeated hour reads the same wall clock as the first and
+        // has already been answered with. Real Scheduler fires once when the clocks
+        // go back, rather than twice.
+        return this.zone.isCanonical(at) ? undefined : at + millisecondsPerMinute;
     }
     /**
      * Whether this expression names a day.
@@ -99,12 +102,12 @@ export class SimCronExpression {
      * Whichever of the two day fields is not `?` is the one that decides, which
      * is why they cannot both say something.
      */
-    allowsDay(date) {
+    allowsDay(read) {
         if (this.fields.dayOfMonth.isAny) {
             // AWS numbers the week from Sunday as one, and JavaScript from Sunday as
             // zero.
-            return this.fields.dayOfWeek.allows(date.getUTCDay() + 1);
+            return this.fields.dayOfWeek.allows(read.weekday + 1);
         }
-        return this.fields.dayOfMonth.allows(date.getUTCDate());
+        return this.fields.dayOfMonth.allows(read.day);
     }
 }

package/dist/util/schedule/sim-schedule-zone-clock.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The wall-clock reading of one instant, as a schedule expression names it.
+ */
+export interface SimScheduleZoneParts {
+    readonly year: number;
+    /** The month as a JavaScript `Date` numbers it, January being zero. */
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+    /** The day of the week, Sunday being zero. */
+    readonly weekday: number;
+}
+/**
+ * Reads what a clock in one zone says at an instant.
+ */
+export type SimScheduleZoneClock = (instant: number) => SimScheduleZoneParts;
+/**
+ * A clock for one zone, refusing a name no zone answers to.
+ *
+ * `Intl.DateTimeFormat` is what knows the offsets, including the two days a
+ * year a zone changes one, so no timezone database travels with this. Which
+ * names there are is therefore the host's own, and a name it has never heard
+ * of is refused here.
+ */
+export declare function simScheduleZoneClock(name: string): SimScheduleZoneClock;

package/dist/util/schedule/sim-schedule-zone-clock.js

@@ -0,0 +1,56 @@
+import { SimScheduleExpressionError } from "./sim-schedule.error.js";
+const weekdays = [
+    "Sun",
+    "Mon",
+    "Tue",
+    "Wed",
+    "Thu",
+    "Fri",
+    "Sat",
+];
+/**
+ * A clock for one zone, refusing a name no zone answers to.
+ *
+ * `Intl.DateTimeFormat` is what knows the offsets, including the two days a
+ * year a zone changes one, so no timezone database travels with this. Which
+ * names there are is therefore the host's own, and a name it has never heard
+ * of is refused here.
+ */
+export function simScheduleZoneClock(name) {
+    const format = zoneFormat(name);
+    return (instant) => {
+        const parts = new Map(format
+            .formatToParts(new Date(instant))
+            .map((part) => [part.type, part.value]));
+        return {
+            year: Number(parts.get("year")),
+            month: Number(parts.get("month")) - 1,
+            day: Number(parts.get("day")),
+            // Midnight reads as 24 under some locales rather than as zero.
+            hour: Number(parts.get("hour")) % 24,
+            minute: Number(parts.get("minute")),
+            weekday: weekdays.indexOf(parts.get("weekday") ?? ""),
+        };
+    };
+}
+/**
+ * The formatter for a zone, which is also what decides the name is one.
+ */
+function zoneFormat(name) {
+    try {
+        return new Intl.DateTimeFormat("en-US", {
+            timeZone: name,
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+        });
+    }
+    catch {
+        throw new SimScheduleExpressionError(`'${name}' is not a timezone. A timezone is an IANA name such as ` +
+            `'Europe/London', or 'UTC'`);
+    }
+}

package/dist/util/schedule/sim-schedule-zone.d.ts

@@ -0,0 +1,58 @@
+import { type SimScheduleZoneParts } from "./sim-schedule-zone-clock.js";
+/**
+ * The zone a schedule expression is read in.
+ *
+ * A cron expression names wall-clock fields, and which instants those are
+ * depends on the zone the schedule was created with. Everything a schedule does
+ * with a calendar therefore goes through one of these, and a schedule created
+ * without a timezone gets the UTC one, which is what every schedule used to
+ * get.
+ */
+export declare class SimScheduleZone {
+    /**
+     * The zone name as the request wrote it, which a describe reports back.
+     */
+    readonly name: string;
+    private readonly clock;
+    private constructor();
+    /**
+     * The zone a name calls for, refusing a name no zone answers to.
+     */
+    static of(name?: string): SimScheduleZone;
+    /**
+     * What a clock in this zone reads at an instant.
+     */
+    partsAt(instant: number): SimScheduleZoneParts;
+    /**
+     * The instant a clock in this zone reads a wall-clock time at.
+     *
+     * Two offsets are in play on the day a zone changes one, so both are tried
+     * and the answer is whichever of them the zone actually reads back. A time
+     * the clocks read twice has two, and the earlier is the answer, which is the
+     * one real Scheduler fires at. A time the clocks skip over has neither, and
+     * the answer is the later of the two, which is the first instant after the
+     * hour that never happened.
+     */
+    instantOf(year: number, month: number, day: number, hour?: number, minute?: number): number;
+    /**
+     * Whether an instant is the one this zone puts its own wall-clock reading at.
+     *
+     * The second of a repeated hour reads the same as the first and is not the
+     * instant that reading resolves to, which is what tells the two apart.
+     */
+    isCanonical(instant: number): boolean;
+    /**
+     * The instants a wall-clock time could be, under the offsets either side of
+     * a change.
+     */
+    private candidatesFor;
+    /**
+     * How far ahead of UTC this zone is at an instant, in milliseconds.
+     */
+    private offsetAt;
+    /**
+     * What a clock in this zone reads at an instant, as a UTC instant of the same
+     * wall-clock fields, which is what makes two readings comparable.
+     */
+    private wallClockOf;
+}

package/dist/util/schedule/sim-schedule-zone.js

@@ -0,0 +1,83 @@
+import { simScheduleZoneClock, } from "./sim-schedule-zone-clock.js";
+const minuteMs = 60_000;
+/**
+ * The zone a schedule expression is read in.
+ *
+ * A cron expression names wall-clock fields, and which instants those are
+ * depends on the zone the schedule was created with. Everything a schedule does
+ * with a calendar therefore goes through one of these, and a schedule created
+ * without a timezone gets the UTC one, which is what every schedule used to
+ * get.
+ */
+export class SimScheduleZone {
+    /**
+     * The zone name as the request wrote it, which a describe reports back.
+     */
+    name;
+    clock;
+    constructor(name, clock) {
+        this.name = name;
+        this.clock = clock;
+    }
+    /**
+     * The zone a name calls for, refusing a name no zone answers to.
+     */
+    static of(name = "UTC") {
+        return new this(name, simScheduleZoneClock(name));
+    }
+    /**
+     * What a clock in this zone reads at an instant.
+     */
+    partsAt(instant) {
+        return this.clock(instant);
+    }
+    /**
+     * The instant a clock in this zone reads a wall-clock time at.
+     *
+     * Two offsets are in play on the day a zone changes one, so both are tried
+     * and the answer is whichever of them the zone actually reads back. A time
+     * the clocks read twice has two, and the earlier is the answer, which is the
+     * one real Scheduler fires at. A time the clocks skip over has neither, and
+     * the answer is the later of the two, which is the first instant after the
+     * hour that never happened.
+     */
+    instantOf(year, month, day, hour = 0, minute = 0) {
+        const wanted = Date.UTC(year, month, day, hour, minute);
+        const candidates = this.candidatesFor(wanted);
+        const read = candidates.filter((candidate) => this.wallClockOf(candidate) === wanted);
+        return read.length === 0 ? Math.max(...candidates) : Math.min(...read);
+    }
+    /**
+     * Whether an instant is the one this zone puts its own wall-clock reading at.
+     *
+     * The second of a repeated hour reads the same as the first and is not the
+     * instant that reading resolves to, which is what tells the two apart.
+     */
+    isCanonical(instant) {
+        const read = this.clock(instant);
+        return (this.instantOf(read.year, read.month, read.day, read.hour, read.minute) === instant);
+    }
+    /**
+     * The instants a wall-clock time could be, under the offsets either side of
+     * a change.
+     */
+    candidatesFor(wanted) {
+        const first = wanted - this.offsetAt(wanted);
+        const second = wanted - this.offsetAt(first);
+        return first === second ? [first] : [first, second];
+    }
+    /**
+     * How far ahead of UTC this zone is at an instant, in milliseconds.
+     */
+    offsetAt(instant) {
+        return (this.wallClockOf(instant) - Math.floor(instant / minuteMs) * minuteMs);
+    }
+    /**
+     * What a clock in this zone reads at an instant, as a UTC instant of the same
+     * wall-clock fields, which is what makes two readings comparable.
+     */
+    wallClockOf(instant) {
+        const read = this.clock(instant);
+        return Date.UTC(read.year, read.month, read.day, read.hour, read.minute);
+    }
+}

package/dist/util/schedule/sim-schedule.d.ts

@@ -16,7 +16,7 @@ export declare class SimSchedule {
     /**
      * Read a schedule expression under a dialect's rules.
      */
-    static of(source: string, dialect: SimScheduleDialect): SimSchedule;
+    static of(source: string, dialect: SimScheduleDialect, timeZone?: string): SimSchedule;
     /**
      * Read the body of whichever form the expression was written in.
      */

package/dist/util/schedule/sim-schedule.js

@@ -1,6 +1,7 @@
 import { SimAtExpression } from "./at/sim-at-expression.js";
 import { SimCronExpression } from "./cron/sim-cron-expression.js";
 import { SimRateExpression } from "./rate/sim-rate-expression.js";
+import { SimScheduleZone } from "./sim-schedule-zone.js";
 import { SimScheduleExpressionError } from "./sim-schedule.error.js";
 const expression = /^(?<kind>[a-z]+)\((?<body>.*)\)$/su;
 /**
@@ -23,27 +24,27 @@ export class SimSchedule {
     /**
      * Read a schedule expression under a dialect's rules.
      */
-    static of(source, dialect) {
+    static of(source, dialect, timeZone) {
         const read = expression.exec(source.trim())?.groups;
         if (read === undefined) {
             throw new SimScheduleExpressionError(`a schedule expression is 'rate(<value> <unit>)' or ` +
                 `'cron(<fields>)', and this one is '${source}'`);
         }
-        return new this(source, this.occurrencesOf(read, dialect));
+        return new this(source, this.occurrencesOf(read, dialect, SimScheduleZone.of(timeZone)));
     }
     /**
      * Read the body of whichever form the expression was written in.
      */
-    static occurrencesOf(read, dialect) {
+    static occurrencesOf(read, dialect, zone) {
         const body = read["body"] ?? "";
         if (read["kind"] === "rate") {
             return SimRateExpression.of(body, dialect.requiresRateAgreement);
         }
         if (read["kind"] === "cron") {
-            return SimCronExpression.of(dialect.cronFields, body);
+            return SimCronExpression.of(dialect.cronFields, body, zone);
         }
         if (read["kind"] === "at" && dialect.allowsOneTime) {
-            return SimAtExpression.of(body);
+            return SimAtExpression.of(body, zone);
         }
         const forms = dialect.allowsOneTime
             ? "an 'at(...)', a 'rate(...)' or a 'cron(...)'"

package/docs/services/athena/README.md

@@ -1107,6 +1107,11 @@ Current documented limitations:
 - A null in a result row reads as an empty string. Real Athena leaves the value out of the row.
 - A computed boolean reads as `1` and `0`. The Glue column type is what makes a boolean column read
   as `true` and `false`, and an expression has no column type behind it.
+- `round(x, 1)` keeps the one decimal place it was asked for, so `25` reads as `25.0` the way Trino
+  renders it, and the column reports `double`. The scale is read off the statement, so a `round`
+  whose scale is an expression rather than a number keeps none of it. Real Athena reports `decimal`
+  where the value being rounded came from a decimal literal, and nothing here tracks decimal
+  precision.
 - An expression nobody named is called `_col0` upward, as Athena calls one. An alias that needed
   quotes around it is renamed the same way.
 - The engine reads every object under the prefixes a query reaches and holds the rows in memory.