@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,127 @@
+import type { IContainEntitiesAndLinks, LinkParams, CreateParams, UpdateParams, UpdateOpts, RuleParams, UniqueKeys, ResolveEntityAttrs } from './schemaTypes.ts';
+type Action = 'create' | 'update' | 'link' | 'unlink' | 'delete' | 'merge' | 'ruleParams';
+type EType = string;
+type Id = string;
+type Args = any;
+type LookupRef = [string, any];
+type Lookup = string;
+type Opts = UpdateOpts;
+export type Op = [Action, EType, Id | LookupRef, Args, Opts?];
+export interface TransactionChunk<Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities']> {
+    __ops: Op[];
+    __etype: EntityName;
+    /**
+     * Create objects. Throws an error if the object with the provided ID already
+     * exists.
+     */
+    create: (args: CreateParams<Schema, EntityName>) => TransactionChunk<Schema, EntityName>;
+    /**
+     * Create and update objects. By default works in upsert mode (will create
+     * entity if that doesn't exist). Can be optionally put into "strict update"
+     * mode by providing { upsert: false } option as second argument:
+     *
+     * @example
+     *  const goalId = id();
+     *  // upsert
+     *  db.tx.goals[goalId].update({title: "Get fit", difficulty: 5})
+     *
+     *  // strict update
+     *  db.tx.goals[goalId].update({title: "Get fit"}, {upsert: false})
+     */
+    update: (args: UpdateParams<Schema, EntityName>, opts?: UpdateOpts) => TransactionChunk<Schema, EntityName>;
+    /**
+     * Link two objects together
+     *
+     * @example
+     * const goalId = id();
+     * const todoId = id();
+     * db.transact([
+     *   db.tx.goals[goalId].update({title: "Get fit"}),
+     *   db.tx.todos[todoId].update({title: "Go on a run"}),
+     *   db.tx.goals[goalId].link({todos: todoId}),
+     * ])
+     *
+     * // Now, if you query:
+     * useQuery({ goals: { todos: {} } })
+     * // You'll get back:
+     *
+     * // { goals: [{ title: "Get fit", todos: [{ title: "Go on a run" }]}
+     */
+    link: (args: LinkParams<Schema, EntityName>) => TransactionChunk<Schema, EntityName>;
+    /**
+     * Unlink two objects
+     * @example
+     *  // to "unlink" a todo from a goal:
+     *  db.tx.goals[goalId].unlink({todos: todoId})
+     */
+    unlink: (args: LinkParams<Schema, EntityName>) => TransactionChunk<Schema, EntityName>;
+    /**
+     * Delete an object, alongside all of its links.
+     *
+     * @example
+     *   db.tx.goals[goalId].delete()
+     */
+    delete: () => TransactionChunk<Schema, EntityName>;
+    /**
+     *
+     * Similar to `update`, but instead of overwriting the current value, it will merge the provided values into the current value.
+     *
+     * This is useful for deeply nested, document-style values, or for updating a single attribute at an arbitrary depth without overwriting the rest of the object.
+     *
+     * For example, if you have a goal with a nested `metrics` object:
+     *
+     * ```js
+     * goal = { name: "Get fit", metrics: { progress: 0.3 } }
+     * ```
+     *
+     * You can update the `progress` attribute like so:
+     *
+     * ```js
+     * db.tx.goals[goalId].merge({ metrics: { progress: 0.5 }, category: "Fitness" })
+     * ```
+     *
+     * And the resulting object will be:
+     *
+     * ```js
+     * goal = { name: "Get fit", metrics: { progress: 0.5 }, category: "Fitness"  }
+     *  ```
+     *
+     * @example
+     *  const goalId = id();
+     *  db.tx.goals[goalId].merge({title: "Get fitter"})
+     */
+    merge: (args: {
+        [attribute: string]: any;
+    }, opts?: UpdateOpts) => TransactionChunk<Schema, EntityName>;
+    ruleParams: (args: RuleParams) => TransactionChunk<Schema, EntityName>;
+}
+export type ETypeChunk<Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities']> = {
+    [id: Id]: TransactionChunk<Schema, EntityName>;
+} & {
+    lookup: <Name extends UniqueKeys<Schema['entities'][EntityName]['attrs']>>(attrName: Name, value: ResolveEntityAttrs<Schema['entities'][EntityName]>[Name]) => TransactionChunk<Schema, EntityName>;
+};
+export type TxChunk<Schema extends IContainEntitiesAndLinks<any, any>> = {
+    [EntityName in keyof Schema['entities']]: ETypeChunk<Schema, EntityName>;
+};
+/**
+ * Creates a lookup to use in place of an id in a transaction
+ *
+ * @example
+ * db.tx.users[lookup('email', 'lyndon@example.com')].update({name: 'Lyndon'})
+ */
+export declare function lookup(attribute: string, value: any): Lookup;
+export declare function isLookup(k: string): boolean;
+export declare function parseLookup(k: string): LookupRef;
+export declare function txInit<Schema extends IContainEntitiesAndLinks<any, any>>(): TxChunk<Schema>;
+/**
+ * A handy builder for changes.
+ *
+ * You must start with the `namespace` you want to change:
+ *
+ * @example
+ *   db.tx.goals[goalId].update({title: "Get fit"})
+ *   // Note: you don't need to create `goals` ahead of time.
+ */
+export declare const tx: TxChunk<IContainEntitiesAndLinks<any, any>>;
+export declare function getOps(x: TransactionChunk<any, any>): Op[];
+export {};

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

@@ -0,0 +1,93 @@
+function getAllTransactionChunkKeys() {
+    const v = 1;
+    const _dummy = {
+        __etype: v,
+        __ops: v,
+        create: v,
+        update: v,
+        link: v,
+        unlink: v,
+        delete: v,
+        merge: v,
+        ruleParams: v,
+    };
+    return new Set(Object.keys(_dummy));
+}
+const allTransactionChunkKeys = getAllTransactionChunkKeys();
+function transactionChunk(etype, id, prevOps) {
+    const target = {
+        __etype: etype,
+        __ops: prevOps,
+    };
+    return new Proxy(target, {
+        get: (_target, cmd) => {
+            if (cmd === '__ops')
+                return prevOps;
+            if (cmd === '__etype')
+                return etype;
+            if (!allTransactionChunkKeys.has(cmd)) {
+                return undefined;
+            }
+            return (args, opts) => {
+                return transactionChunk(etype, id, [
+                    ...prevOps,
+                    opts ? [cmd, etype, id, args, opts] : [cmd, etype, id, args],
+                ]);
+            };
+        },
+    });
+}
+/**
+ * Creates a lookup to use in place of an id in a transaction
+ *
+ * @example
+ * db.tx.users[lookup('email', 'lyndon@example.com')].update({name: 'Lyndon'})
+ */
+export function lookup(attribute, value) {
+    return `lookup__${attribute}__${JSON.stringify(value)}`;
+}
+export function isLookup(k) {
+    return k.startsWith('lookup__');
+}
+export function parseLookup(k) {
+    const [_, attribute, ...vJSON] = k.split('__');
+    return [attribute, JSON.parse(vJSON.join('__'))];
+}
+function etypeChunk(etype) {
+    return new Proxy({
+        __etype: etype,
+    }, {
+        get(_target, cmd) {
+            if (cmd === 'lookup') {
+                return (attrName, value) => transactionChunk(etype, parseLookup(lookup(attrName, value)), []);
+            }
+            if (cmd === '__etype')
+                return etype;
+            const id = cmd;
+            if (isLookup(id)) {
+                return transactionChunk(etype, parseLookup(id), []);
+            }
+            return transactionChunk(etype, id, []);
+        },
+    });
+}
+export function txInit() {
+    return new Proxy({}, {
+        get(_target, ns) {
+            return etypeChunk(ns);
+        },
+    });
+}
+/**
+ * A handy builder for changes.
+ *
+ * You must start with the `namespace` you want to change:
+ *
+ * @example
+ *   db.tx.goals[goalId].update({title: "Get fit"})
+ *   // Note: you don't need to create `goals` ahead of time.
+ */
+export const tx = txInit();
+export function getOps(x) {
+    return x.__ops;
+}

package/node_modules/@instantdb/core/dist/esm/model/instaqlResult.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Marshall instaql-result into list of triples. Instaql-result may have
+ * multiple datalog-results, each datalog-result may have multiple join-rows
+ * and each join-row may have triples.The union of these triples may have
+ * duplicates, so we dedup them.
+ */
+export declare function extractTriples(idNodes: any): any[];

package/node_modules/@instantdb/core/dist/esm/model/instaqlResult.js

@@ -0,0 +1,24 @@
+function _extractTriplesHelper(idNodes, acc = []) {
+    idNodes.forEach((idNode) => {
+        const { data } = idNode;
+        const { 'datalog-result': datalogResult } = data;
+        const { 'join-rows': joinRows } = datalogResult;
+        for (const rows of joinRows) {
+            for (const triple of rows) {
+                acc.push(triple);
+            }
+        }
+        _extractTriplesHelper(idNode['child-nodes'], acc);
+    });
+}
+/**
+ * Marshall instaql-result into list of triples. Instaql-result may have
+ * multiple datalog-results, each datalog-result may have multiple join-rows
+ * and each join-row may have triples.The union of these triples may have
+ * duplicates, so we dedup them.
+ */
+export function extractTriples(idNodes) {
+    const triples = [];
+    _extractTriplesHelper(idNodes, triples);
+    return triples;
+}

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

@@ -0,0 +1,2 @@
+import { InstantSchemaDef } from './schemaTypes.ts';
+export declare const parseSchemaFromJSON: (s: any) => InstantSchemaDef<any, any, any>;

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

@@ -0,0 +1,142 @@
+import { i } from './schema.js';
+export const parseSchemaFromJSON = (s) => {
+    // Parse entities
+    const entities = {};
+    for (const [entityName, entityInfo] of Object.entries(s.entities)) {
+        const entityDef = entityInfo;
+        const attrs = {};
+        // Parse attributes
+        for (const [attrName, attrInfo] of Object.entries(entityDef.attrs)) {
+            const attrDef = attrInfo;
+            let attr;
+            // Create the appropriate attribute type
+            switch (attrDef.valueType) {
+                case 'string':
+                    attr = i.string();
+                    break;
+                case 'number':
+                    attr = i.number();
+                    break;
+                case 'boolean':
+                    attr = i.boolean();
+                    break;
+                case 'date':
+                    attr = i.date();
+                    break;
+                case 'json':
+                    attr = i.json();
+                    break;
+                default:
+                    attr = i.json();
+            }
+            // Apply modifiers
+            if (!attrDef.required) {
+                attr = attr.optional();
+            }
+            if (attrDef.config?.indexed) {
+                attr = attr.indexed();
+            }
+            if (attrDef.config?.unique) {
+                attr = attr.unique();
+            }
+            attrs[attrName] = attr;
+        }
+        entities[entityName] = i.entity(attrs);
+    }
+    // Parse links
+    const links = s.links || {};
+    // Parse rooms
+    const rooms = {};
+    if (s.rooms) {
+        for (const [roomName, roomInfo] of Object.entries(s.rooms)) {
+            const roomDef = roomInfo;
+            // Parse presence
+            const presenceAttrs = {};
+            for (const [attrName, attrInfo] of Object.entries(roomDef.presence.attrs)) {
+                const attrDef = attrInfo;
+                let attr;
+                switch (attrDef.valueType) {
+                    case 'string':
+                        attr = i.string();
+                        break;
+                    case 'number':
+                        attr = i.number();
+                        break;
+                    case 'boolean':
+                        attr = i.boolean();
+                        break;
+                    case 'date':
+                        attr = i.date();
+                        break;
+                    case 'json':
+                        attr = i.json();
+                        break;
+                    default:
+                        attr = i.json();
+                }
+                if (!attrDef.required) {
+                    attr = attr.optional();
+                }
+                if (attrDef.config?.indexed) {
+                    attr = attr.indexed();
+                }
+                if (attrDef.config?.unique) {
+                    attr = attr.unique();
+                }
+                presenceAttrs[attrName] = attr;
+            }
+            // Parse topics
+            const topics = {};
+            if (roomDef.topics) {
+                for (const [topicName, topicInfo] of Object.entries(roomDef.topics)) {
+                    const topicDef = topicInfo;
+                    const topicAttrs = {};
+                    for (const [attrName, attrInfo] of Object.entries(topicDef.attrs)) {
+                        const attrDef = attrInfo;
+                        let attr;
+                        switch (attrDef.valueType) {
+                            case 'string':
+                                attr = i.string();
+                                break;
+                            case 'number':
+                                attr = i.number();
+                                break;
+                            case 'boolean':
+                                attr = i.boolean();
+                                break;
+                            case 'date':
+                                attr = i.date();
+                                break;
+                            case 'json':
+                                attr = i.json();
+                                break;
+                            default:
+                                attr = i.json();
+                        }
+                        if (!attrDef.required) {
+                            attr = attr.optional();
+                        }
+                        if (attrDef.config?.indexed) {
+                            attr = attr.indexed();
+                        }
+                        if (attrDef.config?.unique) {
+                            attr = attr.unique();
+                        }
+                        topicAttrs[attrName] = attr;
+                    }
+                    topics[topicName] = i.entity(topicAttrs);
+                }
+            }
+            rooms[roomName] = {
+                presence: i.entity(presenceAttrs),
+                topics,
+            };
+        }
+    }
+    const resultingSchema = i.schema({
+        entities,
+        links,
+        rooms,
+    });
+    return resultingSchema;
+};

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

@@ -0,0 +1,50 @@
+export type RoomSchemaShape = {
+    [k: string]: {
+        presence?: {
+            [k: string]: any;
+        };
+        topics?: {
+            [k: string]: {
+                [k: string]: any;
+            };
+        };
+    };
+};
+export type PresenceOpts<PresenceShape, Keys extends keyof PresenceShape> = {
+    user?: boolean;
+    peers?: string[];
+    keys?: Keys[];
+    /**
+     * If you haven't joined this room yet, initialPresence lets you set
+     * the very first presence state for the user.
+     */
+    initialPresence?: Partial<PresenceShape>;
+    /** @deprecated use `initialPresence` */
+    initialData?: Partial<PresenceShape>;
+};
+type PresencePeer<PresenceShape, Keys extends keyof PresenceShape> = Pick<PresenceShape, Keys> & {
+    peerId: string;
+};
+export type PresenceSlice<PresenceShape, Keys extends keyof PresenceShape> = {
+    user?: PresencePeer<PresenceShape, Keys>;
+    peers: {
+        [peerId: string]: PresencePeer<PresenceShape, Keys>;
+    };
+};
+export type PresenceResponse<PresenceShape, Keys extends keyof PresenceShape> = PresenceSlice<PresenceShape, Keys> & {
+    isLoading: boolean;
+    error?: string;
+};
+export declare function buildPresenceSlice<PresenceShape, Keys extends keyof PresenceShape>(data: {
+    user?: PresenceShape;
+    peers: Record<string, PresenceShape>;
+}, opts: PresenceOpts<PresenceShape, Keys>, userPeerId: string): PresenceSlice<PresenceShape, Keys>;
+/**
+ * Compare two presence slices
+ * 0. compare isLoading and error
+ * 1. shallow compare user
+ * 2. compare peers keys
+ * 3. shallow compare each peer
+ */
+export declare function hasPresenceResponseChanged<PresenceShape, Keys extends keyof PresenceShape>(a: PresenceResponse<PresenceShape, Keys>, b: PresenceResponse<PresenceShape, Keys>): boolean;
+export {};

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

@@ -0,0 +1,50 @@
+import { pick } from './utils/pick.js';
+import { areObjectsShallowEqual, areObjectKeysEqual } from './utils/object.js';
+export function buildPresenceSlice(data, opts, userPeerId) {
+    const slice = {
+        peers: {},
+    };
+    const includeUser = opts && 'user' in opts ? opts.user : true;
+    if (includeUser) {
+        const user = pick(data.user ?? {}, opts?.keys);
+        slice.user = { ...user, peerId: userPeerId };
+    }
+    for (const id of Object.keys(data.peers ?? {})) {
+        const shouldIncludeAllPeers = opts?.peers === undefined;
+        const isPeerIncluded = Array.isArray(opts?.peers) && opts?.peers.includes(id);
+        if (shouldIncludeAllPeers || isPeerIncluded) {
+            const peer = pick(data.peers[id], opts?.keys);
+            slice.peers[id] = { ...peer, peerId: id };
+        }
+    }
+    return slice;
+}
+/**
+ * Compare two presence slices
+ * 0. compare isLoading and error
+ * 1. shallow compare user
+ * 2. compare peers keys
+ * 3. shallow compare each peer
+ */
+export function hasPresenceResponseChanged(a, b) {
+    if (a.isLoading !== b.isLoading)
+        return true;
+    if (a.error !== b.error)
+        return true;
+    if (a.user || b.user) {
+        if (!a.user || !b.user)
+            return true;
+        const same = areObjectsShallowEqual(a.user, b.user);
+        if (!same)
+            return true;
+    }
+    const sameKeys = areObjectKeysEqual(a.peers, b.peers);
+    if (!sameKeys)
+        return true;
+    for (const id of Object.keys(a.peers)) {
+        const same = areObjectsShallowEqual(a.peers[id], b.peers[id]);
+        if (!same)
+            return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,9 @@
+import type { Expand } from './queryTypes.ts';
+import type { EntityDef, ResolveEntityAttrs, RoomsDef } from './schemaTypes.ts';
+type ExtractPresenceAttrs<PresenceEntity> = PresenceEntity extends EntityDef<any, any, any> ? ResolveEntityAttrs<PresenceEntity> : never;
+export type PresencePeer<Schema extends {
+    rooms: RoomsDef;
+}, RoomType extends Extract<keyof Schema['rooms'], string>> = Expand<ExtractPresenceAttrs<Schema['rooms'][RoomType]['presence']> & {
+    peerId: string;
+}>;
+export {};

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

@@ -0,0 +1,3 @@
+// Presence Utility Types
+// ---------------------
+export {};