@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,243 @@
+// The FrameworkClient class is a mini version of a query store that allows making queries on both the frontend and backend
+// you can register queries, await their results and serialize them over a server/client boundary.
+// The class is generic so that it can be a good starting off point to make other ssr adapters.
+import { coerceQuery, InstantAPIError, InstantError, weakHash, } from './index.js';
+import * as s from './store.js';
+import instaql from './instaql.js';
+import { createLinkIndex } from './utils/linkIndex.js';
+export const isServer = typeof window === 'undefined' || 'Deno' in globalThis;
+export class FrameworkClient {
+    params;
+    db;
+    // stores all of the query promises so that ssr can read them
+    // and send the relevant results alongside the html that resulted in the query resolving
+    resultMap = new Map();
+    queryResolvedCallbacks = [];
+    constructor(params) {
+        this.params = params;
+        this.db = params.db;
+        this.resultMap = new Map();
+    }
+    subscribe = (callback) => {
+        this.queryResolvedCallbacks.push(callback);
+    };
+    // Runs on the client when ssr gets html script tags
+    addQueryResult = (queryKey, value) => {
+        this.resultMap.set(queryKey, {
+            type: value.type,
+            status: 'success',
+            data: value,
+            promise: null,
+            error: null,
+        });
+        // send the result to the client
+        if (!isServer) {
+            // make sure the attrs are there to create stores
+            if (!this.db._reactor.attrs) {
+                this.db._reactor._setAttrs(value.attrs);
+            }
+            this.db._reactor._addQueryData(value.query, value, !!this.db._reactor.config.schema);
+        }
+    };
+    removeCachedQueryResult = (queryHash) => {
+        this.resultMap.delete(queryHash);
+    };
+    // Run a query on the client and return a promise with the result
+    queryClient = (query_, opts) => {
+        const { hash, query } = this.hashQuery(query_, opts);
+        let resolve;
+        let reject;
+        const promise = new Promise((resolvePromise, rejectPromise) => {
+            resolve = resolvePromise;
+            reject = rejectPromise;
+        });
+        let entry = {
+            status: 'pending',
+            type: 'session',
+            data: undefined,
+            error: undefined,
+            promise: promise,
+        };
+        let unsub = null;
+        let unsubImmediately = false;
+        unsub = this.db.subscribeQuery(query, (res) => {
+            if (res.error) {
+                entry.status = 'error';
+                entry.error = res.error;
+                entry.promise = null;
+                reject(res.error);
+            }
+            else {
+                entry.status = 'success';
+                entry.data = res;
+                entry.promise = null;
+                resolve(res);
+            }
+            if (unsub !== null) {
+                unsub();
+            }
+            else {
+                unsubImmediately;
+            }
+        });
+        // We may have gotten the result inside of subscribeQuery before
+        // we defined the `unsub` function
+        if (unsubImmediately) {
+            unsub();
+        }
+        this.resultMap.set(hash, entry);
+        return promise;
+    };
+    // creates an entry in the results map
+    // and returns the same thing added to the map
+    query = (_query, opts) => {
+        const { hash, query } = this.hashQuery(_query, opts);
+        if (this.db._reactor.status === 'authenticated') {
+            const promise = this.db.queryOnce(_query, opts);
+            let entry = {
+                status: 'pending',
+                type: 'session',
+                data: undefined,
+                error: undefined,
+                promise: promise,
+            };
+            promise.then((result) => {
+                entry.status = 'success';
+                entry.data = result;
+                entry.promise = null;
+            });
+            promise.catch((error) => {
+                entry.status = 'error';
+                entry.error = error;
+                entry.promise = null;
+            });
+            this.resultMap.set(hash, entry);
+            return entry;
+        }
+        const promise = this.getTriplesAndAttrsForQuery(query);
+        let entry = {
+            status: 'pending',
+            type: 'http',
+            data: undefined,
+            error: undefined,
+            promise: promise,
+        };
+        promise.then((result) => {
+            entry.status = 'success';
+            entry.data = result;
+            entry.promise = null;
+        });
+        promise.catch((error) => {
+            entry.status = 'error';
+            entry.error = error;
+            entry.promise = null;
+        });
+        promise.then((result) => {
+            this.queryResolvedCallbacks.forEach((callback) => {
+                callback({
+                    queryHash: hash,
+                    query: query,
+                    attrs: result.attrs,
+                    triples: result.triples,
+                    pageInfo: result.pageInfo,
+                });
+            });
+        });
+        this.resultMap.set(hash, entry);
+        return entry;
+    };
+    getExistingResultForQuery = (_query, opts) => {
+        const { hash } = this.hashQuery(_query, opts);
+        return this.resultMap.get(hash);
+    };
+    // creates a query result from a set of triples, query, and attrs
+    // can be run server side or client side
+    completeIsomorphic = (query, triples, attrs, pageInfo) => {
+        const attrMap = {};
+        attrs.forEach((attr) => {
+            attrMap[attr.id] = attr;
+        });
+        const enableCardinalityInference = Boolean(this.db?._reactor?.config?.schema) &&
+            ('cardinalityInference' in this.db?._reactor?.config
+                ? Boolean(this.db?._reactor.config?.cardinalityInference)
+                : true);
+        const attrsStore = new s.AttrsStoreClass(attrs.reduce((acc, attr) => {
+            acc[attr.id] = attr;
+            return acc;
+        }, {}), createLinkIndex(this.db?._reactor.config.schema));
+        const store = s.createStore(attrsStore, triples, enableCardinalityInference, this.params.db._reactor.config.useDateObjects || false);
+        const resp = instaql({
+            store: store,
+            attrsStore: attrsStore,
+            pageInfo: pageInfo,
+            aggregate: undefined,
+        }, query);
+        return resp;
+    };
+    hashQuery = (_query, opts) => {
+        if (_query && opts && 'ruleParams' in opts) {
+            _query = { $$ruleParams: opts['ruleParams'], ..._query };
+        }
+        const query = _query ? coerceQuery(_query) : null;
+        return { hash: weakHash(query), query: query };
+    };
+    // Run by the server to get triples and attrs
+    getTriplesAndAttrsForQuery = async (query) => {
+        try {
+            const response = await fetch(`${this.db._reactor.config.apiURI}/runtime/framework/query`, {
+                method: 'POST',
+                headers: {
+                    'app-id': this.params.db._reactor.config.appId,
+                    'Content-Type': 'application/json',
+                    Authorization: this.params.token
+                        ? `Bearer ${this.params.token}`
+                        : undefined,
+                },
+                body: JSON.stringify({
+                    query: query,
+                }),
+            });
+            if (!response.ok) {
+                try {
+                    const data = await response.json();
+                    if ('message' in data) {
+                        throw new InstantAPIError({ body: data, status: response.status });
+                    }
+                    else {
+                        throw new Error('Error getting triples from server');
+                    }
+                }
+                catch (e) {
+                    if (e instanceof InstantError) {
+                        throw e;
+                    }
+                    throw new Error('Error getting triples from server');
+                }
+            }
+            const data = await response.json();
+            const attrs = data?.attrs;
+            if (!attrs) {
+                throw new Error('No attrs');
+            }
+            // TODO: make safer
+            const triples = data.result?.[0].data?.['datalog-result']?.['join-rows'][0];
+            const pageInfo = data.result?.[0]?.data?.['page-info'];
+            return {
+                attrs,
+                triples,
+                type: 'http',
+                queryHash: this.hashQuery(query).hash,
+                query,
+                pageInfo,
+            };
+        }
+        catch (err) {
+            if (err instanceof InstantError) {
+                throw err;
+            }
+            const errWithMessage = new Error('Error getting triples from framework client');
+            errWithMessage.cause = err;
+            throw errWithMessage;
+        }
+    };
+}

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

@@ -0,0 +1,75 @@
+import type { InstaQLEntity, InstaQLResult, InstaQLParams, Remove$ } from './queryTypes.ts';
+import type { IContainEntitiesAndLinks, InstantSchemaDef } from './schemaTypes.ts';
+import type { IInstantDatabase } from './coreTypes.ts';
+/**
+ * @deprecated
+ * `InstantQuery` is deprecated. Use `InstaQLParams` instead.
+ *
+ * @example
+ *  // Before
+ *  const db = init_experimental({ ...config, schema });
+ *  type DB = typeof db;
+ *  const myQuery = { ... } satisfies InstantQuery<DB>;
+ *
+ *  // After
+ *  type Schema = typeof schema;
+ *  const myQuery = { ... } satisfies InstaQLParams<Schema>;
+ */
+export type InstantQuery<DB extends IInstantDatabase<any>> = DB extends IInstantDatabase<infer Schema> ? InstaQLParams<Schema> : never;
+/**
+ * @deprecated
+ * `InstantQueryResult` is deprecated. Use `InstaQLResult` instead.
+ *
+ * @example
+ * // Before
+ * const db = init_experimental({ ...config, schema });
+ * type DB = typeof db;
+ * type MyQueryResult = InstantQueryResult<DB, typeof myQuery>;
+ *
+ * // After
+ * type Schema = typeof schema;
+ * type MyQueryResult = InstaQLResult<Schema, typeof myQuery>;
+ */
+export type InstantQueryResult<DB extends IInstantDatabase<any>, Q> = DB extends IInstantDatabase<infer Schema> ? Q extends InstaQLParams<Schema> | undefined ? InstaQLResult<Schema, Remove$<Q>> : never : never;
+/**
+ * @deprecated
+ * `InstantSchema` is deprecated. Use typeof schema directly:
+ * @example
+ * // Before
+ * const db = init_experimental({ ...config, schema });
+ * type Schema = InstantSchema<typeof db>;
+ *
+ * // After
+ * type Schema = typeof schema;
+ */
+export type InstantSchema<DB extends IInstantDatabase<any>> = DB extends IInstantDatabase<infer Schema> ? Schema : never;
+/**
+ * @deprecated
+ * `InstantEntity` is deprecated. Use `InstaQLEntity` instead.
+ *
+ * @example
+ * // Before
+ * const db = init_experimental({ ...config, schema });
+ * type DB = typeof db;
+ * type MyEntity = InstantEntity<DB, "myEntityName">;
+ *
+ * // After
+ * type Schema = typeof schema;
+ * type MyEntity = InstaQLEntity<Schema, "myEntityName">;
+ */
+export type InstantEntity<DB extends IInstantDatabase<any>, EntityName extends DB extends IInstantDatabase<infer Schema> ? Schema extends IContainEntitiesAndLinks<infer Entities, any> ? keyof Entities : never : never, Query extends (DB extends IInstantDatabase<infer Schema> ? Schema extends IContainEntitiesAndLinks<infer Entities, any> ? {
+    [QueryPropName in keyof Entities[EntityName]['links']]?: any;
+} : never : never) | {} = {}> = DB extends IInstantDatabase<infer Schema> ? InstaQLEntity<Schema, EntityName, Query> : never;
+/**
+ * @deprecated
+ * `InstantSchemaDatabase` is deprecated. You generally don't need to
+ * create a return type for a DB. But, if you like you can use `IInstantDatabase`:
+ *
+ * @example
+ * // Before
+ * type DB = InstantSchemaDatabase<typeof schema>;
+ *
+ * // After
+ * type DB = IInstantDatabase<typeof schema>;
+ */
+export type InstantSchemaDatabase<Schema extends InstantSchemaDef<any, any, any>, _T1 extends any = any, _T2 extends any = any> = IInstantDatabase<Schema>;

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

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