@sincpro/mobile 0.4.4 → 1.0.0

package/dist/domain/database/criteria_clock.js

@@ -0,0 +1,305 @@
+import { InvalidCriteria } from "@sincpro/criteria";
+const UNITS = ["minutes", "hours", "days", "weeks", "months", "years"];
+const GRAINS = ["day", "week", "month", "quarter", "year"];
+export function deviceClock(now = new Date()) {
+    return {
+        now,
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    };
+}
+export function readCriteriaValue(value, clock, field = "") {
+    if (Array.isArray(value)) {
+        return value.map((item) => readCriteriaValue(item, clock, field));
+    }
+    if (!isDynamic(value) || value.$ === "field")
+        return value;
+    if (value.$ === "today")
+        return resolveToday(value, clock);
+    if (value.$ === "now")
+        return resolveNow(value, clock);
+    if (value.$ === "period") {
+        const who = field.length > 0 ? `; '${field}' asked for it so` : "";
+        throw new InvalidCriteria(`a period is a range and cannot be one item of a list${who}`);
+    }
+    if (value.$ === "context" || value.$ === "param") {
+        throw new InvalidCriteria("a context or parameter value is not read on the device");
+    }
+    throw new InvalidCriteria(`'${value.$}' is not read on the device`);
+}
+function resolveToday(value, clock) {
+    const span = spanOf(value.plus);
+    if ((span.hours ?? 0) !== 0 || (span.minutes ?? 0) !== 0) {
+        throw new InvalidCriteria("a date has no hours or minutes; use `now` to move by them");
+    }
+    const moved = value.plus === undefined ? zonedDay(clock) : shiftCalendar(zonedDay(clock), span);
+    const snapped = snap(moved, grainOf(value.start_of));
+    return formatDay(snapped);
+}
+function resolveNow(value, clock) {
+    const span = spanOf(value.plus);
+    const grain = grainOf(value.start_of);
+    let utc = clock.now;
+    if (value.plus !== undefined) {
+        const wall = zonedWall(clock);
+        const shifted = {
+            ...shiftCalendar(wall, span),
+            hour: wall.hour,
+            minute: wall.minute,
+            second: wall.second,
+            milli: wall.milli,
+        };
+        const elapsed = ((span.hours ?? 0) * 60 + (span.minutes ?? 0)) * 60_000;
+        utc = new Date(wallToUtc(shifted, clock.timeZone).getTime() + elapsed);
+    }
+    if (grain === undefined)
+        return utc.toISOString();
+    const start = snap(zonedWall({ now: utc, timeZone: clock.timeZone }), grain);
+    return wallToUtc({ ...start, hour: 0, minute: 0, second: 0, milli: 0 }, clock.timeZone).toISOString();
+}
+function zonedDay(clock) {
+    const wall = zonedWall(clock);
+    return { year: wall.year, month: wall.month, day: wall.day };
+}
+function zonedWall(clock) {
+    let parts;
+    try {
+        parts = new Intl.DateTimeFormat("en-US", {
+            timeZone: clock.timeZone,
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        }).formatToParts(clock.now);
+    }
+    catch {
+        throw new InvalidCriteria(`unknown timezone '${clock.timeZone}'`);
+    }
+    const read = (type) => {
+        const found = parts.find((part) => part.type === type)?.value;
+        if (found === undefined || !/^\d+$/.test(found)) {
+            throw new InvalidCriteria(`unknown timezone '${clock.timeZone}'`);
+        }
+        return Number(found);
+    };
+    return {
+        year: read("year"),
+        month: read("month"),
+        day: read("day"),
+        hour: read("hour") % 24,
+        minute: read("minute"),
+        second: read("second"),
+        milli: clock.now.getUTCMilliseconds(),
+    };
+}
+function shiftCalendar(day, span) {
+    const months = (span.months ?? 0) + (span.years ?? 0) * 12;
+    const index = day.year * 12 + day.month - 1 + months;
+    const year = Math.floor(index / 12);
+    const month = index - year * 12 + 1;
+    const last = new Date(Date.UTC(year, month, 0)).getUTCDate();
+    const moved = new Date(Date.UTC(year, month - 1, Math.min(day.day, last) + (span.days ?? 0) + 7 * (span.weeks ?? 0)));
+    return {
+        year: moved.getUTCFullYear(),
+        month: moved.getUTCMonth() + 1,
+        day: moved.getUTCDate(),
+    };
+}
+function snap(day, grain) {
+    if (grain === undefined || grain === "day")
+        return day;
+    if (grain === "year")
+        return { year: day.year, month: 1, day: 1 };
+    if (grain === "month")
+        return { year: day.year, month: day.month, day: 1 };
+    if (grain === "quarter") {
+        return {
+            year: day.year,
+            month: 3 * Math.floor((day.month - 1) / 3) + 1,
+            day: 1,
+        };
+    }
+    const utc = new Date(Date.UTC(day.year, day.month - 1, day.day));
+    const mondayBased = (utc.getUTCDay() + 6) % 7;
+    const start = new Date(utc.getTime() - mondayBased * 86_400_000);
+    return {
+        year: start.getUTCFullYear(),
+        month: start.getUTCMonth() + 1,
+        day: start.getUTCDate(),
+    };
+}
+function wallToUtc(wall, timeZone) {
+    const guess = Date.UTC(wall.year, wall.month - 1, wall.day, wall.hour, wall.minute, wall.second);
+    const corrected = guess - zoneOffset(new Date(guess), timeZone);
+    const again = guess - zoneOffset(new Date(corrected), timeZone);
+    return new Date(again + wall.milli);
+}
+function zoneOffset(instant, timeZone) {
+    const wall = zonedWall({ now: instant, timeZone });
+    return (Date.UTC(wall.year, wall.month - 1, wall.day, wall.hour, wall.minute, wall.second) -
+        (instant.getTime() - wall.milli));
+}
+function formatDay(day) {
+    const month = String(day.month).padStart(2, "0");
+    const date = String(day.day).padStart(2, "0");
+    return `${day.year}-${month}-${date}`;
+}
+const PERIOD_NAMES = [
+    "today",
+    "yesterday",
+    "tomorrow",
+    "this_week",
+    "last_week",
+    "next_week",
+    "this_month",
+    "last_month",
+    "next_month",
+    "this_quarter",
+    "last_quarter",
+    "next_quarter",
+    "this_year",
+    "last_year",
+    "next_year",
+];
+const PERIOD_STARTS = {
+    today: ["day", 0],
+    yesterday: ["day", -1],
+    tomorrow: ["day", 1],
+    this_week: ["week", 0],
+    last_week: ["week", -1],
+    next_week: ["week", 1],
+    this_month: ["month", 0],
+    last_month: ["month", -1],
+    next_month: ["month", 1],
+    this_quarter: ["quarter", 0],
+    last_quarter: ["quarter", -1],
+    next_quarter: ["quarter", 1],
+    this_year: ["year", 0],
+    last_year: ["year", -1],
+    next_year: ["year", 1],
+};
+export function periodBounds(value, clock) {
+    const period = parsePeriod(value);
+    const today = zonedDay(clock);
+    if (period.kind === "name") {
+        const [grain, away] = PERIOD_STARTS[period.name];
+        const start = snap(shiftCalendar(today, scale(grainSpan(grain), away)), grain);
+        return [formatDay(start), formatDay(shiftCalendar(start, grainSpan(grain)))];
+    }
+    const current = snap(today, period.unit);
+    const step = grainSpan(period.unit);
+    const at = (amount) => shiftCalendar(current, scale(step, amount));
+    if (period.side === "last") {
+        return [
+            formatDay(at(period.includeCurrent ? -(period.count - 1) : -period.count)),
+            formatDay(at(period.includeCurrent ? 1 : 0)),
+        ];
+    }
+    return [
+        formatDay(at(period.includeCurrent ? 0 : 1)),
+        formatDay(at(period.includeCurrent ? period.count : period.count + 1)),
+    ];
+}
+function grainSpan(grain) {
+    if (grain === "day")
+        return { days: 1 };
+    if (grain === "week")
+        return { weeks: 1 };
+    if (grain === "month")
+        return { months: 1 };
+    if (grain === "quarter")
+        return { months: 3 };
+    return { years: 1 };
+}
+function scale(span, amount) {
+    const scaled = {};
+    for (const unit of UNITS) {
+        const step = span[unit];
+        if (step !== undefined)
+            scaled[unit] = step * amount;
+    }
+    return scaled;
+}
+function parsePeriod(value) {
+    if (!isDynamic(value) || value.$ !== "period") {
+        throw new InvalidCriteria("a period is a name, or a unit with `last` or `next`");
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+        if (!["$", "name", "unit", "last", "next", "include_current"].includes(key)) {
+            throw new InvalidCriteria(`'${key}' is not part of a period`);
+        }
+    }
+    const name = record.name;
+    const unit = record.unit;
+    const last = record.last;
+    const next = record.next;
+    const include = record.include_current;
+    const counted = [last, next].filter((one) => one !== undefined);
+    if (name !== undefined) {
+        if (typeof name !== "string" || !PERIOD_NAMES.includes(name)) {
+            throw new InvalidCriteria(`'${String(name)}' is not a period the engine declares; use one of ${PERIOD_NAMES.join(", ")}`);
+        }
+        if (unit !== undefined || counted.length > 0 || include) {
+            throw new InvalidCriteria("a named period takes nothing else; `unit`, `last`, `next` and `include_current` describe a window");
+        }
+        return { kind: "name", name: name };
+    }
+    if (grainOf(unit) === undefined || counted.length !== 1) {
+        throw new InvalidCriteria('a period is a name, or a unit with `last` or `next`: {"$": "period", "unit": "day", "last": 30}');
+    }
+    const count = counted[0];
+    if (typeof count !== "number" || !Number.isInteger(count) || count < 1) {
+        throw new InvalidCriteria(`a period counts at least one unit; got ${String(count)}`);
+    }
+    if (include !== undefined && typeof include !== "boolean") {
+        throw new InvalidCriteria("include_current is true or false");
+    }
+    return {
+        kind: "window",
+        unit: unit,
+        side: last === undefined ? "next" : "last",
+        count,
+        includeCurrent: include === true,
+    };
+}
+function spanOf(plus) {
+    if (plus === undefined)
+        return {};
+    if (plus === null || typeof plus !== "object" || Array.isArray(plus)) {
+        throw new InvalidCriteria("a span names calendar units");
+    }
+    const record = plus;
+    for (const key of Object.keys(record)) {
+        if (!UNITS.includes(key)) {
+            throw new InvalidCriteria(`'${key}' is not a span unit`);
+        }
+    }
+    const span = {};
+    for (const unit of UNITS) {
+        const amount = record[unit];
+        if (amount === undefined)
+            continue;
+        if (typeof amount !== "number" || !Number.isInteger(amount)) {
+            throw new InvalidCriteria("a span counts whole units");
+        }
+        span[unit] = amount;
+    }
+    return span;
+}
+function grainOf(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "string" && GRAINS.includes(value))
+        return value;
+    throw new InvalidCriteria(`'${String(value)}' is not a calendar grain`);
+}
+function isDynamic(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        !(value instanceof Date) &&
+        "$" in value);
+}

package/dist/domain/database/criteria_sql.d.ts

@@ -0,0 +1,61 @@
+import { type Operator } from "@sincpro/criteria";
+import { type DocumentCriteria } from "./criteria";
+import { type CriteriaClock, deviceClock } from "./criteria_clock";
+export type SqlParam = string | number | null;
+export interface CriteriaSqlTarget {
+    table: string;
+    column(field: string): boolean;
+    relation?(name: string): CriteriaSqlTarget | undefined;
+}
+export interface FieldRef {
+    kind: "column" | "json";
+    name: string;
+    path: string;
+}
+export type Predicate = {
+    op: "true";
+} | {
+    op: "false";
+} | {
+    op: "not";
+    item: Predicate;
+} | {
+    op: "and" | "or";
+    items: Predicate[];
+} | {
+    op: "exists";
+    table: string;
+    link: string;
+    item: Predicate;
+} | {
+    op: "cmp";
+    left: FieldRef;
+    operator: Operator;
+    right: {
+        field: FieldRef;
+    } | {
+        value: SqlParam | SqlParam[];
+    };
+};
+export interface CompiledCriteria {
+    whereSql: string;
+    params: SqlParam[];
+    orderSql: string;
+    order: {
+        ref: FieldRef;
+        descending: boolean;
+    }[];
+    limit?: number;
+    offset: number;
+    predicate: Predicate;
+}
+export interface SqlDocument {
+    uuid: string;
+    version: number;
+    data: string;
+    columns: Record<string, SqlParam>;
+}
+export type { CriteriaClock };
+export { deviceClock };
+export declare function compileCriteria<T>(asked: DocumentCriteria<T>, target: CriteriaSqlTarget, clock?: CriteriaClock): CompiledCriteria;
+export declare function rowsFor(compiled: CompiledCriteria, rows: readonly SqlDocument[], others?: (table: string) => readonly SqlDocument[]): SqlDocument[];