@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/core/dist/esm/attrTypes.d.ts

@@ -0,0 +1,25 @@
+type id = string;
+type etype = string;
+type label = string;
+export type InstantDBIdent = [id, etype, label];
+export type InstantDBInferredType = 'number' | 'string' | 'boolean' | 'json';
+export type InstantDBCheckedDataType = 'number' | 'string' | 'boolean' | 'date';
+export type InstantDBAttrOnDelete = 'cascade';
+export type InstantDBAttr = {
+    id: string;
+    'value-type': 'blob' | 'ref';
+    cardinality: 'many' | 'one';
+    'forward-identity': InstantDBIdent;
+    'reverse-identity'?: InstantDBIdent | null | undefined;
+    'unique?': boolean;
+    'index?': boolean;
+    'required?': boolean;
+    'inferred-types': InstantDBInferredType[] | null;
+    catalog: 'system' | 'user';
+    'on-delete'?: InstantDBAttrOnDelete | null | undefined;
+    'on-delete-reverse'?: InstantDBAttrOnDelete | null | undefined;
+    'checked-data-type'?: InstantDBCheckedDataType | null | undefined;
+    'indexing?'?: boolean;
+    'setting-unique?'?: boolean;
+};
+export {};

package/node_modules/@instantdb/core/dist/esm/attrTypes.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@instantdb/core/dist/esm/authAPI.d.ts

@@ -0,0 +1,64 @@
+import { User } from './clientTypes.ts';
+type SharedInput = {
+    apiURI: string;
+    appId: string;
+};
+export type SendMagicCodeParams = {
+    email: string;
+};
+export type SendMagicCodeResponse = {
+    sent: true;
+};
+export declare function sendMagicCode({ apiURI, appId, email, }: SharedInput & SendMagicCodeParams): Promise<SendMagicCodeResponse>;
+export type VerifyMagicCodeParams = {
+    email: string;
+    code: string;
+    refreshToken?: string | undefined;
+};
+export type VerifyResponse = {
+    user: User;
+};
+/**
+ * @deprecated Use {@link checkMagicCode} instead to get the `created` field
+ * and support `extraFields`.
+ */
+export declare function verifyMagicCode({ apiURI, appId, email, code, refreshToken, }: SharedInput & VerifyMagicCodeParams): Promise<VerifyResponse>;
+export type CheckMagicCodeParams = {
+    email: string;
+    code: string;
+    refreshToken?: string | undefined;
+    extraFields?: Record<string, any> | undefined;
+};
+export type CheckMagicCodeResponse = {
+    user: User;
+    created: boolean;
+};
+export declare function checkMagicCode({ apiURI, appId, email, code, refreshToken, extraFields, }: SharedInput & CheckMagicCodeParams): Promise<CheckMagicCodeResponse>;
+export type VerifyRefreshTokenParams = {
+    refreshToken: string;
+};
+export declare function verifyRefreshToken({ apiURI, appId, refreshToken, }: SharedInput & VerifyRefreshTokenParams): Promise<VerifyResponse>;
+export type SignInAsGuestParams = {
+    extraFields?: Record<string, any> | undefined;
+};
+export declare function signInAsGuest({ apiURI, appId, extraFields, }: SharedInput & SignInAsGuestParams): Promise<VerifyResponse>;
+export type ExchangeCodeForTokenParams = {
+    code: string;
+    codeVerifier?: string;
+    refreshToken?: string | undefined;
+    extraFields?: Record<string, any> | undefined;
+};
+export declare function exchangeCodeForToken({ apiURI, appId, code, codeVerifier, refreshToken, extraFields, }: SharedInput & ExchangeCodeForTokenParams): Promise<CheckMagicCodeResponse>;
+export type SignInWithIdTokenParams = {
+    nonce?: string | null | undefined;
+    idToken: string;
+    clientName: string;
+    refreshToken?: string;
+    extraFields?: Record<string, any> | undefined;
+};
+export declare function signInWithIdToken({ apiURI, appId, nonce, idToken, clientName, refreshToken, extraFields, }: SharedInput & SignInWithIdTokenParams): Promise<CheckMagicCodeResponse>;
+export type SignoutParams = {
+    refreshToken: string;
+};
+export declare function signOut({ apiURI, appId, refreshToken, }: SharedInput & SignoutParams): Promise<{}>;
+export {};

package/node_modules/@instantdb/core/dist/esm/authAPI.js

@@ -0,0 +1,103 @@
+import { jsonFetch } from './utils/fetch.js';
+export function sendMagicCode({ apiURI, appId, email, }) {
+    return jsonFetch(`${apiURI}/runtime/auth/send_magic_code`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ 'app-id': appId, email }),
+    });
+}
+/**
+ * @deprecated Use {@link checkMagicCode} instead to get the `created` field
+ * and support `extraFields`.
+ */
+export async function verifyMagicCode({ apiURI, appId, email, code, refreshToken, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/auth/verify_magic_code`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            'app-id': appId,
+            email,
+            code,
+            ...(refreshToken ? { 'refresh-token': refreshToken } : {}),
+        }),
+    });
+    return res;
+}
+export async function checkMagicCode({ apiURI, appId, email, code, refreshToken, extraFields, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/auth/verify_magic_code`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            'app-id': appId,
+            email,
+            code,
+            ...(refreshToken ? { 'refresh-token': refreshToken } : {}),
+            ...(extraFields ? { 'extra-fields': extraFields } : {}),
+        }),
+    });
+    return res;
+}
+export async function verifyRefreshToken({ apiURI, appId, refreshToken, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/auth/verify_refresh_token`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            'app-id': appId,
+            'refresh-token': refreshToken,
+        }),
+    });
+    return res;
+}
+export async function signInAsGuest({ apiURI, appId, extraFields, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/auth/sign_in_guest`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            'app-id': appId,
+            ...(extraFields ? { 'extra-fields': extraFields } : {}),
+        }),
+    });
+    return res;
+}
+export async function exchangeCodeForToken({ apiURI, appId, code, codeVerifier, refreshToken, extraFields, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/oauth/token`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            app_id: appId,
+            code: code,
+            code_verifier: codeVerifier,
+            refresh_token: refreshToken,
+            ...(extraFields ? { extra_fields: extraFields } : {}),
+        }),
+    });
+    return res;
+}
+export async function signInWithIdToken({ apiURI, appId, nonce, idToken, clientName, refreshToken, extraFields, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/oauth/id_token`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            app_id: appId,
+            nonce,
+            id_token: idToken,
+            client_name: clientName,
+            refresh_token: refreshToken,
+            ...(extraFields ? { extra_fields: extraFields } : {}),
+        }),
+    });
+    return res;
+}
+export async function signOut({ apiURI, appId, refreshToken, }) {
+    const res = await jsonFetch(`${apiURI}/runtime/signout`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            app_id: appId,
+            refresh_token: refreshToken,
+        }),
+    });
+    return res;
+}

package/node_modules/@instantdb/core/dist/esm/clientTypes.d.ts

@@ -0,0 +1,40 @@
+export type User = {
+    id: string;
+    refresh_token: string;
+    email?: string | null | undefined;
+    imageURL?: string | null | undefined;
+    type?: 'user' | 'guest' | undefined;
+    isGuest: boolean;
+};
+export type AuthResult = {
+    user: User | undefined;
+    error: undefined;
+} | {
+    user: undefined;
+    error: {
+        message: string;
+    };
+};
+export type AuthState = {
+    isLoading: true;
+    error: undefined;
+    user: undefined;
+} | {
+    isLoading: false;
+    error: {
+        message: string;
+    };
+    user: undefined;
+} | {
+    isLoading: false;
+    error: undefined;
+    user: User | null | undefined;
+};
+export type ConnectionStatus = 'connecting' | 'opened' | 'authenticated' | 'closed' | 'errored';
+export type AppStatusState = {
+    isLoading: true;
+    isReadOnly: undefined;
+} | {
+    isLoading: false;
+    isReadOnly: boolean;
+};

package/node_modules/@instantdb/core/dist/esm/clientTypes.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@instantdb/core/dist/esm/coreTypes.d.ts

@@ -0,0 +1,33 @@
+import { TxChunk } from './instatx.ts';
+import { RoomSchemaShape } from './presence.ts';
+import type { IContainEntitiesAndLinks, InstantSchemaDef } from './schemaTypes.ts';
+export interface IDatabase<Schema extends IContainEntitiesAndLinks<any, any> | {} = {}, _RoomSchema extends RoomSchemaShape = {}, WithCardinalityInference extends boolean = false> {
+    tx: TxChunk<Schema extends IContainEntitiesAndLinks<any, any> ? Schema : InstantSchemaDef<any, any, any>>;
+    withCardinalityInference?: WithCardinalityInference;
+}
+export interface IInstantDatabase<Schema extends InstantSchemaDef<any, any, any>> {
+    tx: TxChunk<Schema>;
+}
+export type DevtoolPosition = 'bottom-left' | 'bottom-right' | 'top-right' | 'top-left';
+export type DevtoolConfig = {
+    /**
+     * Position of the devtool panel on the screen
+     * @default 'bottom-right'
+     */
+    position?: DevtoolPosition;
+    /**
+     * Hosts where the devtool should be shown
+     * @default ['localhost']
+     */
+    allowedHosts?: string[];
+    /**
+     * Dashboard URI used to render the devtool
+     * @default 'https://instantdb.com'
+     */
+    dashURI?: string;
+};
+export type StrictDevtoolConfig = {
+    position: DevtoolPosition;
+    allowedHosts: string[];
+    dashURI?: string;
+};

package/node_modules/@instantdb/core/dist/esm/coreTypes.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@instantdb/core/dist/esm/createRouteHandler.d.ts

@@ -0,0 +1,7 @@
+type CreateRouteHandlerConfig = {
+    appId: string;
+};
+export declare const createInstantRouteHandler: (config: CreateRouteHandlerConfig) => {
+    POST: (req: Request) => Promise<Response>;
+};
+export {};

package/node_modules/@instantdb/core/dist/esm/createRouteHandler.js

@@ -0,0 +1,51 @@
+function createUserSyncResponse(config, user) {
+    if (user && user.refresh_token) {
+        return new Response(JSON.stringify({ ok: true }), {
+            headers: {
+                'Content-Type': 'application/json',
+                // 7 day expiry
+                'Set-Cookie': `instant_user_${config.appId}=${encodeURIComponent(JSON.stringify(user))}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=604800`,
+            },
+        });
+    }
+    else {
+        return new Response(JSON.stringify({ ok: true }), {
+            headers: {
+                'Content-Type': 'application/json',
+                // remove the cookie (some browsers)
+                'Set-Cookie': `instant_user_${config.appId}=; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=-1`,
+            },
+        });
+    }
+}
+function errorResponse(status, message) {
+    return new Response(JSON.stringify({ ok: false, error: message }), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+export const createInstantRouteHandler = (config) => {
+    return {
+        POST: async (req) => {
+            let body;
+            try {
+                body = await req.json();
+            }
+            catch {
+                return errorResponse(400, 'Invalid JSON body');
+            }
+            if (!body.type) {
+                return errorResponse(400, 'Missing "type" field');
+            }
+            if (body.appId !== config.appId) {
+                return errorResponse(403, 'App ID mismatch');
+            }
+            switch (body.type) {
+                case 'sync-user':
+                    return createUserSyncResponse(config, body.user ?? null);
+                default:
+                    return errorResponse(400, `Unknown type: ${body.type}`);
+            }
+        },
+    };
+};

package/node_modules/@instantdb/core/dist/esm/datalog.d.ts

@@ -0,0 +1,7 @@
+export declare function matchPattern(pattern: any, triple: any, context: any): any;
+export declare function querySingle(store: any, pattern: any, context: any): any[];
+export declare function queryWhere(store: any, patterns: any, contexts?: {}[]): any;
+export declare function query(store: any, { find, where }: {
+    find: any;
+    where: any;
+}): any;

package/node_modules/@instantdb/core/dist/esm/datalog.js

@@ -0,0 +1,99 @@
+// 1. patternMatch
+import { getTriples } from './store.js';
+function isVariable(x) {
+    return typeof x === 'string' && x.startsWith('?');
+}
+function matchVariable(variable, triplePart, context) {
+    if (context.hasOwnProperty(variable)) {
+        const bound = context[variable];
+        return matchPart(bound, triplePart, context);
+    }
+    return { ...context, [variable]: triplePart };
+}
+function matchExact(patternPart, triplePart, context) {
+    return patternPart === triplePart ? context : null;
+}
+function matcherForPatternPart(patternPart) {
+    switch (typeof patternPart) {
+        case 'string':
+            return patternPart.startsWith('?') ? matchVariable : matchExact;
+        default:
+            return matchExact;
+    }
+}
+const validArgMapProps = [
+    'in',
+    '$in',
+    '$not',
+    '$isNull',
+    '$comparator', // covers all of $gt, $lt, etc.
+];
+// Checks if an object is an args map
+function isArgsMap(patternPart) {
+    for (const prop of validArgMapProps) {
+        if (patternPart.hasOwnProperty(prop)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchPart(patternPart, triplePart, context) {
+    if (!context)
+        return null;
+    if (typeof patternPart === 'object') {
+        // This is an args map, so we'll have already fitered the triples
+        // in `getRelevantTriples`
+        if (isArgsMap(patternPart)) {
+            return context;
+        }
+        return null;
+    }
+    const matcher = matcherForPatternPart(patternPart);
+    return matcher(patternPart, triplePart, context);
+}
+export function matchPattern(pattern, triple, context) {
+    return pattern.reduce((context, patternPart, idx) => {
+        const triplePart = triple[idx];
+        return matchPart(patternPart, triplePart, context);
+    }, context);
+}
+// 2. querySingle
+export function querySingle(store, pattern, context) {
+    return relevantTriples(store, pattern, context)
+        .map((triple) => matchPattern(pattern, triple, context))
+        .filter((x) => x);
+}
+// 3. queryWhere
+function queryPattern(store, pattern, contexts) {
+    if (pattern.or) {
+        return pattern.or.patterns.flatMap((patterns) => {
+            return queryWhere(store, patterns, contexts);
+        });
+    }
+    if (pattern.and) {
+        return pattern.and.patterns.reduce((contexts, patterns) => {
+            return queryWhere(store, patterns, contexts);
+        }, contexts);
+    }
+    return contexts.flatMap((context) => querySingle(store, pattern, context));
+}
+export function queryWhere(store, patterns, contexts = [{}]) {
+    return patterns.reduce((contexts, pattern) => {
+        return queryPattern(store, pattern, contexts);
+    }, contexts);
+}
+// 4. query
+function actualize(context, find) {
+    if (Array.isArray(find)) {
+        return find.map((findPart) => actualize(context, findPart));
+    }
+    return isVariable(find) ? context[find] : find;
+}
+export function query(store, { find, where }) {
+    const contexts = queryWhere(store, where);
+    return contexts.map((context) => actualize(context, find));
+}
+// 5. Index
+function relevantTriples(store, pattern, context) {
+    return getTriples(store, actualize(context, pattern));
+}

package/node_modules/@instantdb/core/dist/esm/devtool.d.ts

@@ -0,0 +1,3 @@
+import { StrictDevtoolConfig } from './coreTypes.ts';
+export declare function createDevtool(appId: string, config: StrictDevtoolConfig): void;
+export declare function getDevtoolSrc(appId: string, config: StrictDevtoolConfig): string;

package/node_modules/@instantdb/core/dist/esm/devtool.js

@@ -0,0 +1,144 @@
+import * as flags from './utils/flags.js';
+let currentDevtool;
+export function createDevtool(appId, config) {
+    currentDevtool?.dispose();
+    const iframeContrainer = createIframeContainer(config);
+    const toggler = createToggler(config, toggleView);
+    const iframe = createIframe(getDevtoolSrc(appId, config));
+    function onPostMessage(event) {
+        if (event.source !== iframe.element.contentWindow)
+            return;
+        if (event.data?.type === 'close' && iframeContrainer.isVisible()) {
+            toggleView();
+        }
+    }
+    function onKeyDown(event) {
+        const isToggleShortcut = event.shiftKey && event.ctrlKey && event.code === 'Digit0';
+        const isEsc = event.key === 'Escape' || event.key === 'Esc';
+        if (isToggleShortcut) {
+            toggleView();
+        }
+        else if (isEsc && iframeContrainer.isVisible()) {
+            toggleView();
+        }
+    }
+    function toggleView() {
+        if (iframeContrainer.isVisible()) {
+            iframeContrainer.element.style.display = 'none';
+        }
+        else {
+            iframeContrainer.element.style.display = 'block';
+            // lazily render iframe on first open
+            if (!iframeContrainer.element.contains(iframe.element)) {
+                iframeContrainer.element.appendChild(iframe.element);
+            }
+        }
+    }
+    function dispose() {
+        iframeContrainer.element.remove();
+        toggler.element.remove();
+        removeEventListener('keydown', onKeyDown);
+        removeEventListener('message', onPostMessage);
+    }
+    function create() {
+        document.body.appendChild(iframeContrainer.element);
+        document.body.appendChild(toggler.element);
+        addEventListener('keydown', onKeyDown);
+        addEventListener('message', onPostMessage);
+        currentDevtool = {
+            dispose,
+        };
+    }
+    return create();
+}
+export function getDevtoolSrc(appId, config) {
+    const useLocalDashboard = flags.devBackend || flags.devtoolLocalDashboard;
+    const dashURI = config.dashURI ??
+        (useLocalDashboard ? 'http://localhost:3000' : 'https://instantdb.com');
+    return `${dashURI.replace(/\/+$/, '')}/_devtool?appId=${appId}`;
+}
+function createIframe(src) {
+    const element = document.createElement('iframe');
+    element.src = src;
+    element.className = 'instant-devtool-iframe';
+    Object.assign(element.style, {
+        width: '100%',
+        height: '100%',
+        backgroundColor: 'white',
+        border: 'none',
+    });
+    return { element };
+}
+function createToggler(config, onClick) {
+    const logoSVG = `
+    <svg width="32" height="32" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <rect width="512" height="512" fill="black"/>
+      <rect x="97.0973" y="91.3297" width="140" height="330" fill="white"/>
+    </svg>
+  `;
+    const element = document.createElement('button');
+    element.innerHTML = logoSVG;
+    element.className = 'instant-devtool-toggler';
+    Object.assign(element.style, {
+        // pos
+        position: 'fixed',
+        ...cssPositionForToggler(config.position),
+        height: '32px',
+        width: '32px',
+        // layout
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        zIndex: '9010',
+        // look
+        padding: '0',
+        margin: '0',
+        border: 'none',
+        cursor: 'pointer',
+    });
+    element.addEventListener('click', onClick);
+    return { element };
+}
+function cssPositionForToggler(position) {
+    switch (position) {
+        case 'bottom-left':
+            return { bottom: '24px', left: '24px' };
+        case 'bottom-right':
+            return { bottom: '24px', right: '24px' };
+        case 'top-right':
+            return { top: '24px', right: '24px' };
+        case 'top-left':
+            return { top: '24px', left: '24px' };
+    }
+}
+function cssPositionForIframeContainer(position) {
+    switch (position) {
+        case 'bottom-left':
+            return { bottom: '24px', right: '24px', left: '60px', top: '72px' };
+        case 'bottom-right':
+            return { bottom: '24px', left: '24px', right: '60px', top: '72px' };
+        case 'top-right':
+            return { top: '24px', left: '24px', right: '60px', bottom: '72px' };
+        case 'top-left':
+            return { top: '24px', right: '24px', left: '60px', bottom: '72px' };
+    }
+}
+function createIframeContainer(config) {
+    const element = document.createElement('div');
+    Object.assign(element.style, {
+        position: 'fixed',
+        ...cssPositionForIframeContainer(config.position),
+        display: 'block',
+        borderRadius: '4px',
+        border: '1px #ccc solid',
+        boxShadow: '0px 0px 8px #00000044',
+        backgroundColor: '#eee',
+        zIndex: '999990',
+    });
+    element.style.display = 'none';
+    element.className = 'instant-devtool-container';
+    function isVisible() {
+        return element.style.display !== 'none';
+    }
+    return { element, isVisible };
+}

package/node_modules/@instantdb/core/dist/esm/framework.d.ts

@@ -0,0 +1,80 @@
+import { InstantCoreDatabase, InstantDBAttr } from './index.ts';
+import { RuleParams } from './schemaTypes.ts';
+export declare const isServer: boolean;
+export type FrameworkConfig = {
+    token?: string | null;
+    db: InstantCoreDatabase<any, any>;
+};
+type QueryPromise = {
+    type: 'http';
+    triples: any;
+    attrs: any;
+    queryHash: any;
+    query: any;
+    pageInfo?: any;
+} | {
+    type: 'session';
+    queryResult: any;
+};
+export declare class FrameworkClient {
+    private params;
+    private db;
+    resultMap: Map<string, {
+        status: 'pending' | 'success' | 'error';
+        type: 'http' | 'session';
+        promise?: Promise<QueryPromise> | null;
+        data?: any;
+        error?: any;
+    }>;
+    private queryResolvedCallbacks;
+    constructor(params: FrameworkConfig);
+    subscribe: (callback: (result: {
+        triples: any;
+        attrs: any;
+        queryHash: string;
+        pageInfo?: any;
+    }) => void) => void;
+    addQueryResult: (queryKey: string, value: any) => void;
+    removeCachedQueryResult: (queryHash: string) => void;
+    queryClient: (query_: any, opts?: {
+        ruleParams: RuleParams;
+    }) => Promise<QueryPromise>;
+    query: (_query: any, opts?: {
+        ruleParams: RuleParams;
+    }) => {
+        type: 'http' | 'session';
+        status: 'pending' | 'success' | 'error';
+        promise?: Promise<QueryPromise>;
+        data?: any;
+        error?: any;
+    };
+    getExistingResultForQuery: (_query: any, opts?: {
+        ruleParams: RuleParams;
+    }) => {
+        status: 'pending' | 'success' | 'error';
+        type: 'http' | 'session';
+        promise?: Promise<QueryPromise> | null;
+        data?: any;
+        error?: any;
+    } | undefined;
+    completeIsomorphic: (query: any, triples: any[], attrs: InstantDBAttr[], pageInfo?: any) => {
+        data: any;
+        pageInfo?: any;
+        aggregate?: any;
+    };
+    hashQuery: (_query: any, opts?: {
+        ruleParams: RuleParams;
+    }) => {
+        hash: string;
+        query: any;
+    };
+    getTriplesAndAttrsForQuery: (query: any) => Promise<{
+        triples: any[];
+        attrs: InstantDBAttr[];
+        query: any;
+        queryHash: string;
+        type: 'http';
+        pageInfo?: any;
+    }>;
+}
+export {};