@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/core/dist/esm/utils/dates.js

@@ -0,0 +1,211 @@
+import { pgTimezoneMatch, pgTimezoneAbbrevs } from './pgtime.js';
+// Date parsing functions
+function zonedDateTimeStrToInstant(s) {
+    return new Date(s);
+}
+function localDateTimeStrToInstant(s) {
+    // Parse as UTC since there's no timezone info
+    return new Date(s + 'Z');
+}
+const localDateStrRe = /^(\d+)[\./-](\d+)[\./-](\d+)$/;
+function localDateStrToInstant(s) {
+    const match = s.match(localDateStrRe);
+    if (!match) {
+        return null;
+    }
+    const [_, part1, part2, part3] = match;
+    if (part1 <= 0 || part2 <= 0 || part3 <= 0) {
+        return null;
+    }
+    if (part1 > 999) {
+        return new Date(Date.UTC(part1, part2 - 1, part3, 0, 0, 0, 0));
+    }
+    return new Date(Date.UTC(part3, part1 - 1, part2, 0, 0, 0, 0));
+}
+// Custom date formatters
+function offioDateStrToInstant(s) {
+    // Format: "yyyy-MM-dd HH:mm:ss"
+    // Treat as UTC
+    const [datePart, timePart] = s.split(' ');
+    return new Date(datePart + 'T' + timePart + 'Z');
+}
+function zenecaDateStrToInstant(s) {
+    // Format: "yyyy-MM-dd HH:mm:ss.n"
+    // Treat as UTC
+    const [datePart, timeWithNanos] = s.split(' ');
+    // JavaScript Date can handle fractional seconds
+    return new Date(datePart + 'T' + timeWithNanos + 'Z');
+}
+function rfc1123ToInstant(s) {
+    // RFC 1123 format is natively supported by Date constructor
+    return new Date(s);
+}
+function dowMonDayYearStrToInstant(s) {
+    // Format: "EEE MMM dd yyyy" (e.g., "Wed Jan 15 2025")
+    //Only parse if the string is in the correct format
+    const regex = /^(\w{3}) (\w{3}) (\d{2}) (\d{4})$/;
+    const match = s.match(regex);
+    if (!match) {
+        throw new Error(`Unable to parse \`${s}\` as a date.`);
+    }
+    const date = new Date(s + ' UTC'); // Force UTC parsing
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 0, 0, 0, 0));
+}
+function iso8601IncompleteOffsetToInstant(s) {
+    // Format: "2025-01-02T00:00:00-08" (missing minutes in timezone offset)
+    // Convert to proper ISO 8601 format by adding ":00" to the timezone offset
+    const regex = /^(.+T.+)([+-])(\d{2})$/;
+    const match = s.match(regex);
+    if (match) {
+        const [, dateTimePart, sign, hours] = match;
+        const correctedString = `${dateTimePart}${sign}${hours}:00`;
+        return new Date(correctedString);
+    }
+    return null;
+}
+function iso8601SingleDigitToInstant(s) {
+    // Format: "2025-11-2T00:00:00.000Z" or "2025-1-2T00:00:00Z" (single-digit month/day)
+    // Also handles space separator: "2025-1-2 00:00:00"
+    // Also handles single-digit hours/minutes/seconds: "2026-04-28T04:7:00.000Z"
+    // Normalize to proper ISO 8601 format with two-digit values
+    const regex = /^(\d+)-(\d{1,2})-(\d{1,2})([ T])(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2}))?(.*)$/;
+    const match = s.match(regex);
+    if (match) {
+        const [, year, month, day, _separator, hours, minutes, seconds, rest] = match;
+        const paddedMonth = month.padStart(2, '0');
+        const paddedDay = day.padStart(2, '0');
+        let timeStr = hours.padStart(2, '0');
+        if (minutes !== undefined) {
+            timeStr += `:${minutes.padStart(2, '0')}`;
+        }
+        if (seconds !== undefined) {
+            timeStr += `:${seconds.padStart(2, '0')}`;
+        }
+        const correctedString = `${year}-${paddedMonth}-${paddedDay}T${timeStr}${rest}`;
+        return new Date(correctedString);
+    }
+    return null;
+}
+function usDateTimeStrToInstant(s) {
+    // Format: "M/d/yyyy, h:mm:ss a" (e.g., "8/4/2025, 11:02:31 PM")
+    const [datePart, timePart] = s.split(', ');
+    const [month, day, year] = datePart.split('/').map(Number);
+    // Parse time with AM/PM
+    const timeMatch = timePart.match(/(\d{1,2}):(\d{2}):(\d{2}) (AM|PM)/);
+    if (!timeMatch) {
+        throw new Error(`Unable to parse time from: ${s}`);
+    }
+    let [, hours, minutes, seconds, ampm] = timeMatch;
+    hours = Number(hours);
+    minutes = Number(minutes);
+    seconds = Number(seconds);
+    // Convert 12-hour to 24-hour format
+    if (ampm === 'PM' && hours !== 12) {
+        hours += 12;
+    }
+    else if (ampm === 'AM' && hours === 12) {
+        hours = 0;
+    }
+    // Create date in UTC
+    return new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds));
+}
+// https://www.postgresql.org/docs/17/datatype-datetime.html#DATATYPE-DATETIME-SPECIAL-VALUES
+function specialStrToInstant(s) {
+    switch (s) {
+        case 'epoch':
+            return new Date(0);
+        // These are not implemented yet because we need some way for the
+        // client and server to aggree on the values
+        case 'infinity':
+        case '-infinity':
+        case 'today':
+        case 'tomorrow':
+        case 'yesterday':
+            return null;
+    }
+}
+function pgTimezoneStrToInstant(s) {
+    const match = s.match(pgTimezoneMatch);
+    if (!match) {
+        return null;
+    }
+    const [tz] = match;
+    const offset = pgTimezoneAbbrevs[tz];
+    const baseDate = new Date(s.replace(pgTimezoneMatch, 'Z'));
+    return new Date(baseDate.getTime() - offset * 1000);
+}
+// Array of parsers
+const dateParsers = [
+    localDateStrToInstant,
+    zenecaDateStrToInstant,
+    dowMonDayYearStrToInstant,
+    usDateTimeStrToInstant,
+    localDateTimeStrToInstant,
+    iso8601IncompleteOffsetToInstant,
+    offioDateStrToInstant,
+    zonedDateTimeStrToInstant,
+    specialStrToInstant,
+    pgTimezoneStrToInstant,
+    iso8601SingleDigitToInstant,
+    rfc1123ToInstant,
+];
+// Try to parse with a specific parser
+function tryParseDateString(parser, s) {
+    try {
+        const result = parser(s);
+        // Check if result is valid date
+        if (result instanceof Date && !isNaN(result.getTime())) {
+            return result;
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+// Try all parsers until one succeeds
+function dateStrToInstant(s) {
+    for (const parser of dateParsers) {
+        const instant = tryParseDateString(parser, s);
+        if (instant) {
+            return instant;
+        }
+    }
+    return null;
+}
+// Parse JSON string and then try date parsing
+function jsonStrToInstant(maybeJson) {
+    try {
+        const s = JSON.parse(maybeJson);
+        if (typeof s === 'string') {
+            return dateStrToInstant(s);
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+// Main parse function that handles strings and numbers
+export function coerceToDate(x) {
+    if (x === undefined) {
+        return undefined;
+    }
+    if (x === null) {
+        return null;
+    }
+    if (x instanceof Date) {
+        return x;
+    }
+    if (typeof x === 'string') {
+        const result = dateStrToInstant(x) || jsonStrToInstant(x) || dateStrToInstant(x.trim());
+        if (!result) {
+            throw new Error(`Unable to parse \`${x}\` as a date.`);
+        }
+        return result;
+    }
+    else if (typeof x === 'number') {
+        return new Date(x);
+    }
+    throw new Error(`Invalid date value \`${x}\`. Expected a date, number, or string, got type ${typeof x}.`);
+}

package/node_modules/@instantdb/core/dist/esm/utils/error.d.ts

@@ -0,0 +1,2 @@
+export declare function assert(condition: any, msg?: string): asserts condition;
+export declare function assertUnreachable(_x: never): never;

package/node_modules/@instantdb/core/dist/esm/utils/error.js

@@ -0,0 +1,8 @@
+export function assert(condition, msg) {
+    if (!condition) {
+        throw new Error('[assertion error] ' + msg);
+    }
+}
+export function assertUnreachable(_x) {
+    throw new Error('[assertion error] TS should prevent us from reaching here');
+}

package/node_modules/@instantdb/core/dist/esm/utils/fetch.d.ts

@@ -0,0 +1,125 @@
+import { InstantError } from '../InstantError.ts';
+type InstantIssueBody = {
+    type: 'param-missing';
+    message: string;
+    hint: {
+        in: string[];
+    };
+} | {
+    type: 'param-malformed';
+    message: string;
+    hint: {
+        in: string[];
+    };
+} | {
+    type: 'record-not-found';
+    message: string;
+    hint: {
+        'record-type': string;
+    };
+} | {
+    type: 'record-not-unique';
+    message: string;
+    hint: {
+        'record-type': string;
+    };
+} | {
+    type: 'validation-failed';
+    message: string;
+    hint: {
+        'data-type': string;
+        errors: any[];
+    };
+} | {
+    type: 'record-expired';
+    message: string;
+    hint: {
+        'record-type': string;
+    };
+} | {
+    type: 'record-foreign-key-invalid';
+    message: string;
+    hint: {
+        table?: string;
+        condition?: string;
+        constraint?: string;
+    };
+} | {
+    type: 'record-check-violation';
+    message: string;
+    hint: {
+        table?: string;
+        condition?: string;
+        constraint?: string;
+    };
+} | {
+    type: 'permission-denied';
+    message: string;
+    hint: {
+        input: any;
+        expected: string;
+    };
+} | {
+    type: 'permission-evaluation-failed';
+    message: string;
+    hint: {
+        rule: [string, string];
+        error?: {
+            type: string;
+            message: string;
+            hint: any;
+        };
+    };
+} | {
+    type: 'sql-raise';
+    message: string;
+    hint: {
+        table?: string;
+        condition?: string;
+        constraint?: string;
+    };
+} | {
+    type: 'sql-exception';
+    message: string;
+    hint: {
+        table?: string;
+        condition?: string;
+        constraint?: string;
+    };
+} | {
+    type: 'rate-limited';
+    message: string;
+    hint: {
+        'retry-at'?: string;
+        'retry-after'?: number;
+        'remaining-tokens'?: number;
+    };
+} | {
+    type: 'session-missing';
+    message: string;
+    hint: {
+        'sess-id': string;
+    };
+} | {
+    type: 'socket-missing';
+    message: string;
+    hint: {
+        'sess-id': string;
+        'exception-message'?: string;
+    };
+} | {
+    type: undefined;
+    [k: string]: any;
+} | undefined;
+export type InstantIssue = {
+    body: InstantIssueBody;
+    status: number;
+};
+export declare class InstantAPIError extends InstantError {
+    body: InstantIssueBody;
+    status: number;
+    constructor(error: InstantIssue);
+    get [Symbol.toStringTag](): string;
+}
+export declare function jsonFetch(input: RequestInfo, init: RequestInit | undefined): Promise<any>;
+export {};

package/node_modules/@instantdb/core/dist/esm/utils/fetch.js

@@ -0,0 +1,31 @@
+import { InstantError } from '../InstantError.js';
+export class InstantAPIError extends InstantError {
+    body;
+    status;
+    constructor(error) {
+        // Create a descriptive message based on the error
+        const message = error.body?.message || `API Error (${error.status})`;
+        super(message, error.body.hint, error.body?.traceId || error.body['trace-id']);
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
+        // Maintain proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, InstantAPIError);
+        }
+        this.name = 'InstantAPIError';
+        this.status = error.status;
+        this.body = error.body;
+    }
+    get [Symbol.toStringTag]() {
+        return 'InstantAPIError';
+    }
+}
+export async function jsonFetch(input, init) {
+    const res = await fetch(input, init);
+    const json = await res.json();
+    return res.status === 200
+        ? Promise.resolve(json)
+        : Promise.reject(new InstantAPIError({ status: res.status, body: json }));
+}

package/node_modules/@instantdb/core/dist/esm/utils/flags.d.ts

@@ -0,0 +1,4 @@
+declare let devBackend: boolean;
+declare let instantLogs: boolean;
+declare let devtoolLocalDashboard: boolean;
+export { devBackend, instantLogs, devtoolLocalDashboard };

package/node_modules/@instantdb/core/dist/esm/utils/flags.js

@@ -0,0 +1,10 @@
+let devBackend = false;
+let instantLogs = false;
+let devtoolLocalDashboard = false;
+if (typeof window !== 'undefined' &&
+    typeof window.localStorage !== 'undefined') {
+    devBackend = !!window.localStorage.getItem('devBackend');
+    instantLogs = !!window.localStorage.getItem('__instantLogging');
+    devtoolLocalDashboard = !!window.localStorage.getItem('__devtoolLocalDash');
+}
+export { devBackend, instantLogs, devtoolLocalDashboard };

package/node_modules/@instantdb/core/dist/esm/utils/id.d.ts

@@ -0,0 +1,3 @@
+export declare function uuidCompare(uuid_a: string, uuid_b: string): -1 | 0 | 1;
+declare function id(): string;
+export default id;

package/node_modules/@instantdb/core/dist/esm/utils/id.js

@@ -0,0 +1,25 @@
+import { v4 } from 'uuid';
+function uuidToByteArray(uuid) {
+    const hex = uuid.replace(/-/g, '');
+    const bytes = [];
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes.push(parseInt(hex.substring(i, i + 2), 16));
+    }
+    return bytes;
+}
+function compareByteArrays(a, b) {
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] < b[i])
+            return -1;
+        if (a[i] > b[i])
+            return 1;
+    }
+    return 0;
+}
+export function uuidCompare(uuid_a, uuid_b) {
+    return compareByteArrays(uuidToByteArray(uuid_a), uuidToByteArray(uuid_b));
+}
+function id() {
+    return v4();
+}
+export default id;

package/node_modules/@instantdb/core/dist/esm/utils/linkIndex.d.ts

@@ -0,0 +1,7 @@
+import type { InstantGraph, LinkDef, LinksDef } from '../schemaTypes.ts';
+export type LinkIndex = Record<string, Record<string, {
+    isForward: boolean;
+    isSingular: boolean;
+    link: LinkDef<any, any, any, any, any, any, any>;
+}>>;
+export declare function createLinkIndex(schema: InstantGraph<any, LinksDef<{}>>): LinkIndex;

package/node_modules/@instantdb/core/dist/esm/utils/linkIndex.js

@@ -0,0 +1,17 @@
+export function createLinkIndex(schema) {
+    return Object.values(schema.links).reduce((linkIndex, link) => {
+        linkIndex[link.forward.on] ??= {};
+        linkIndex[link.forward.on][link.forward.label] = {
+            isForward: true,
+            isSingular: link.forward.has === 'one',
+            link,
+        };
+        linkIndex[link.reverse.on] ??= {};
+        linkIndex[link.reverse.on][link.reverse.label] = {
+            isForward: false,
+            isSingular: link.reverse.has === 'one',
+            link,
+        };
+        return linkIndex;
+    }, {});
+}

package/node_modules/@instantdb/core/dist/esm/utils/log.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    info: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+export default function createLogger(isEnabled: boolean, getStats: () => Record<string, any>, baseLogger?: Logger): Logger;

package/node_modules/@instantdb/core/dist/esm/utils/log.js

@@ -0,0 +1,13 @@
+export default function createLogger(isEnabled, getStats, baseLogger = console) {
+    return {
+        info: isEnabled
+            ? (...args) => baseLogger.info(...args, getStats())
+            : () => { },
+        debug: isEnabled
+            ? (...args) => baseLogger.debug(...args, getStats())
+            : () => { },
+        error: isEnabled
+            ? (...args) => baseLogger.error(...args, getStats())
+            : () => { },
+    };
+}

package/node_modules/@instantdb/core/dist/esm/utils/object.d.ts

@@ -0,0 +1,16 @@
+export declare function areObjectKeysEqual(a: any, b: any): boolean;
+export declare function areObjectsShallowEqual(obj1: any, obj2: any): boolean;
+export declare function areObjectsDeepEqual(obj1: any, obj2: any): any;
+export declare function immutableRemoveUndefined(obj: any): any;
+export declare function immutableDeepMerge(target: any, source: any): any;
+export declare function immutableDeepReplace(target: any, replaceValue: any, replacementValue: any): any;
+export declare function isObject(val: any): boolean;
+export declare function immutableOmitValue(obj: any, v: any): void;
+/**
+ * Like `assocInMutative`, but
+ *
+ * - for arrays: inserts the value at the specified index, instead of replacing it
+ */
+export declare function insertInMutative(obj: any, path: any, value: any): void;
+export declare function assocInMutative(obj: any, path: any, value: any): void;
+export declare function dissocInMutative(obj: any, path: any): void;

package/node_modules/@instantdb/core/dist/esm/utils/object.js

@@ -0,0 +1,143 @@
+export function areObjectKeysEqual(a, b) {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    return (ak.length === bk.length && Object.keys(a).every((k) => b.hasOwnProperty(k)));
+}
+export function areObjectsShallowEqual(obj1, obj2) {
+    return (Object.keys(obj1).length === Object.keys(obj2).length &&
+        Object.keys(obj1).every((key) => obj2.hasOwnProperty(key) && obj1[key] === obj2[key]));
+}
+export function areObjectsDeepEqual(obj1, obj2) {
+    if (typeof obj1 !== 'object' ||
+        typeof obj2 !== 'object' ||
+        obj1 === null ||
+        obj2 === null) {
+        return obj1 === obj2;
+    }
+    if (!areObjectKeysEqual(obj1, obj2)) {
+        return false;
+    }
+    return Object.keys(obj1).every((key) => areObjectsDeepEqual(obj1[key], obj2[key]));
+}
+export function immutableRemoveUndefined(obj) {
+    if (!isObject(obj)) {
+        return obj;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined)
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+export function immutableDeepMerge(target, source) {
+    if (!isObject(target) || !isObject(source)) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        if (source[key] === undefined)
+            continue;
+        if (source[key] === null) {
+            delete result[key];
+            continue;
+        }
+        const areBothObjects = isObject(target[key]) && isObject(source[key]);
+        result[key] = areBothObjects
+            ? immutableDeepMerge(target[key], source[key])
+            : source[key];
+    }
+    return result;
+}
+export function immutableDeepReplace(target, replaceValue, replacementValue) {
+    if (!isObject(target)) {
+        return target;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        result[key] = isObject(value)
+            ? immutableDeepReplace(value, replaceValue, replacementValue)
+            : value === replaceValue
+                ? replacementValue
+                : value;
+    }
+    return result;
+}
+export function isObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+export function immutableOmitValue(obj, v) { }
+/**
+ * Like `assocInMutative`, but
+ *
+ * - for arrays: inserts the value at the specified index, instead of replacing it
+ */
+export function insertInMutative(obj, path, value) {
+    if (!obj) {
+        return;
+    }
+    if (path.length === 0) {
+        return;
+    }
+    let current = obj || {};
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current) || typeof current[key] !== 'object') {
+            current[key] = typeof path[i + 1] === 'number' ? [] : {};
+        }
+        current = current[key];
+    }
+    const key = path[path.length - 1];
+    if (Array.isArray(current) && typeof key === 'number') {
+        current.splice(key, 0, value);
+    }
+    else {
+        current[key] = value;
+    }
+}
+export function assocInMutative(obj, path, value) {
+    if (!obj) {
+        return;
+    }
+    if (path.length === 0) {
+        return;
+    }
+    let current = obj || {};
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current) || typeof current[key] !== 'object') {
+            current[key] = typeof path[i + 1] === 'number' ? [] : {};
+        }
+        current = current[key];
+    }
+    current[path[path.length - 1]] = value;
+}
+export function dissocInMutative(obj, path) {
+    if (!obj) {
+        return;
+    }
+    if (path.length === 0) {
+        return;
+    }
+    const [key, ...restPath] = path;
+    if (!(key in obj)) {
+        return;
+    }
+    if (restPath.length === 0) {
+        if (Array.isArray(obj)) {
+            obj.splice(key, 1);
+        }
+        else {
+            delete obj[key];
+        }
+        return;
+    }
+    dissocInMutative(obj[key], restPath);
+    if (isEmpty(obj[key])) {
+        delete obj[key];
+    }
+}
+function isEmpty(obj) {
+    return obj && Object.keys(obj).length === 0;
+}