@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,271 @@
+import type { EntitiesDef, IContainEntitiesAndLinks, InstantGraph, LinkAttrDef, RuleParams, ResolveAttrs, ResolveEntityAttrs, DataAttrDef, AttrsDefs, EntityDefFromSchema, InstantUnknownSchemaDef } from './schemaTypes.ts';
+type BuiltIn = Date | Function | Error | RegExp;
+type Primitive = string | number | boolean | symbol | null | undefined;
+export type Expand<T> = T extends BuiltIn | Primitive ? T : T extends object ? T extends infer O ? {
+    [K in keyof O]: Expand<O[K]>;
+} : never : T;
+export type NonEmpty<T> = {
+    [K in keyof T]-?: Required<Pick<T, K>>;
+}[keyof T];
+type BaseWhereClauseValueComplex<V> = {
+    /** @deprecated use `$in` instead of `in` */
+    in?: V[];
+    $in?: V[];
+    /** @deprecated use `$ne` instead of `not` */
+    $not?: V;
+    $ne?: V;
+    $gt?: V;
+    $lt?: V;
+    $gte?: V;
+    $lte?: V;
+};
+type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+type WhereClauseValueComplex<V, R, I> = BaseWhereClauseValueComplex<V> & (IsAny<V> extends true ? {
+    $ilike?: string;
+    $like?: string;
+    $isNull?: boolean;
+} : (V extends string ? {
+    $like?: string;
+} : {}) & (R extends false ? {
+    $isNull?: boolean;
+} : {}) & (I extends true ? {
+    $ilike?: string;
+} : {}));
+type WhereClauseValue<D extends DataAttrDef<string | number | boolean, boolean, boolean, boolean>> = D extends DataAttrDef<infer V, infer R, infer I, boolean> ? (IsAny<V> extends true ? string | number | boolean : V) | NonEmpty<WhereClauseValueComplex<V, R, I>> : never;
+type WhereClauseColumnEntries<T extends {
+    [key: string]: DataAttrDef<any, boolean, boolean, boolean>;
+}> = {
+    [key in keyof T]?: WhereClauseValue<T[key]>;
+};
+type WhereClauseComboEntries<T extends Record<any, DataAttrDef<any, boolean, boolean, boolean>>> = {
+    or?: WhereClauses<T>[] | WhereClauseValue<DataAttrDef<any, false, true, boolean>>;
+    and?: WhereClauses<T>[] | WhereClauseValue<DataAttrDef<any, false, true, boolean>>;
+};
+type WhereClauses<T extends Record<any, DataAttrDef<any, boolean, boolean, boolean>>> = (WhereClauseComboEntries<T> | (WhereClauseComboEntries<T> & WhereClauseColumnEntries<T>)) & {
+    id?: WhereClauseValue<DataAttrDef<string, false, true, boolean>>;
+    [key: `${string}.${string}`]: WhereClauseValue<DataAttrDef<any, false, true, boolean>>;
+};
+/**
+ * A tuple representing a cursor.
+ * These should not be constructed manually. The current format
+ * is an implementation detail that may change in the future.
+ * Use the `endCursor` or `startCursor` from the PageInfoResponse as the
+ * `before` or `after` field in the query options.
+ */
+type Cursor = [string, string, any, number];
+type Direction = 'asc' | 'desc';
+type IndexedKeys<Attrs extends AttrsDefs> = {
+    [K in keyof Attrs]: Attrs[K] extends DataAttrDef<any, any, infer IsIndexed, boolean> ? IsIndexed extends true ? K : never : never;
+}[keyof Attrs];
+export type Order<Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities']> = IndexedKeys<Schema['entities'][EntityName]['attrs']> extends never ? {
+    serverCreatedAt?: Direction;
+} : {
+    [K in IndexedKeys<Schema['entities'][EntityName]['attrs']>]?: Direction;
+} & {
+    serverCreatedAt?: Direction;
+};
+type $Option<S extends IContainEntitiesAndLinks<any, any>, K extends keyof S['entities']> = {
+    $?: {
+        where?: WhereClauses<EntityDefFromSchema<S, K>>;
+        order?: Order<S, K>;
+        limit?: number;
+        last?: number;
+        first?: number;
+        offset?: number;
+        after?: Cursor;
+        afterInclusive?: boolean;
+        before?: Cursor;
+        beforeInclusive?: boolean;
+        fields?: InstaQLFields<S, K>;
+    };
+};
+type NamespaceVal = $Option<IContainEntitiesAndLinks<any, any>, keyof EntitiesDef> | ($Option<IContainEntitiesAndLinks<any, any>, keyof EntitiesDef> & Subquery);
+type Subquery = {
+    [namespace: string]: NamespaceVal;
+};
+interface Query {
+    [namespace: string]: NamespaceVal;
+}
+type InstantObject = {
+    id: string;
+    [prop: string]: any;
+};
+type ResponseObject<K, Schema> = K extends keyof Schema ? {
+    id: string;
+} & Schema[K] : InstantObject;
+type IsEmptyObject<T> = T extends Record<string, never> ? true : false;
+type ResponseOf<Q, Schema> = {
+    [K in keyof Q]: IsEmptyObject<Q[K]> extends true ? ResponseObject<K, Schema>[] : (ResponseOf<Q[K], Schema> & ResponseObject<K, Schema>)[];
+};
+type Remove$<T> = T extends object ? {
+    [K in keyof T as Exclude<K, '$'>]: Remove$<T[K]>;
+} : T;
+type Remove$NonRecursive<T> = T extends object ? {
+    [K in keyof T as Exclude<K, '$'>]: T[K];
+} : T;
+type QueryResponse<Q, Schema, WithCardinalityInference extends boolean = false, UseDates extends boolean = false> = Schema extends InstantGraph<infer E, any> ? InstaQLQueryResult<E, Q, WithCardinalityInference, UseDates> : ResponseOf<{
+    [K in keyof Q]: Remove$<Q[K]>;
+}, Schema>;
+type InstaQLResponse<Schema, Q, UseDates extends boolean = false> = Schema extends IContainEntitiesAndLinks<any, any> ? Q extends InstaQLParams<Schema> | undefined ? InstaQLResult<Schema, Q, UseDates> : never : never;
+type PageInfoResponse<T> = {
+    [K in keyof T]: {
+        startCursor: Cursor;
+        endCursor: Cursor;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+    };
+};
+/**
+ * (XXX)
+ * https://github.com/microsoft/TypeScript/issues/26051
+ *
+ * TypeScript can permit extra keys when a generic extends a type.
+ *
+ * For some reason, it makes it possible to write a query like so:
+ *
+ * dummyQuery({
+ *  users: {
+ *    $: { where: { "foo": 1 } },
+ *    posts: {
+ *      $: { "far": {} }
+ *    }
+ *  }
+ *
+ *  The problem: $: { "far": {} }
+ *
+ *  This passes, when it should in reality fail. I don't know why
+ *  adding `Exactly` fixes this, but it does.
+ *
+ * */
+type Exactly<Parent, Child> = Parent & {
+    [K in keyof Child]: K extends keyof Parent ? Child[K] : never;
+};
+type SafeLookup<T, K extends readonly PropertyKey[]> = K extends [
+    infer First,
+    ...infer Rest extends readonly PropertyKey[]
+] ? First extends keyof NonNullable<T> ? SafeLookup<NonNullable<T>[First], Rest> | (T extends null | undefined ? undefined : never) : undefined : T;
+type InstaQLEntitySubqueryResult<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, EntityName extends keyof Schema['entities'], Query extends InstaQLEntitySubquery<Schema, EntityName> | undefined = {}, UseDates extends boolean = false> = {
+    [QueryPropName in keyof Query]: Schema['entities'][EntityName]['links'][QueryPropName] extends LinkAttrDef<infer Cardinality, infer LinkedEntityName> ? LinkedEntityName extends keyof Schema['entities'] ? Cardinality extends 'one' ? InstaQLEntity<Schema, LinkedEntityName, Remove$NonRecursive<SafeLookup<Query, [QueryPropName]>>, SafeLookup<Query, [QueryPropName, '$', 'fields']>, UseDates> | undefined : InstaQLEntity<Schema, LinkedEntityName, Remove$NonRecursive<SafeLookup<Query, [QueryPropName]>>, SafeLookup<Query, [QueryPropName, '$', 'fields']>, UseDates>[] : never : never;
+};
+type InstaQLQueryEntityLinksResult<Entities extends EntitiesDef, EntityName extends keyof Entities, Query extends {
+    [LinkAttrName in keyof Entities[EntityName]['links']]?: any;
+}, WithCardinalityInference extends boolean, UseDates extends boolean = false> = {
+    [QueryPropName in keyof Query]: Entities[EntityName]['links'][QueryPropName] extends LinkAttrDef<infer Cardinality, infer LinkedEntityName> ? LinkedEntityName extends keyof Entities ? WithCardinalityInference extends true ? Cardinality extends 'one' ? InstaQLQueryEntityResult<Entities, LinkedEntityName, Query[QueryPropName], WithCardinalityInference, UseDates> | undefined : InstaQLQueryEntityResult<Entities, LinkedEntityName, Query[QueryPropName], WithCardinalityInference, UseDates>[] : InstaQLQueryEntityResult<Entities, LinkedEntityName, Query[QueryPropName], WithCardinalityInference, UseDates>[] : never : never;
+};
+type DistributePick<T, K extends string> = T extends any ? {
+    [P in K]: P extends keyof T ? T[P] : never;
+} : never;
+type InstaQLFields<S extends IContainEntitiesAndLinks<any, any>, K extends keyof S['entities']> = (Extract<keyof ResolveEntityAttrs<S['entities'][K]>, string> | 'id')[];
+type ComputeAttrs<AllAttrs, Fields extends readonly string[] | undefined> = Fields extends readonly string[] ? DistributePick<AllAttrs, Exclude<Fields[number], 'id'>> : AllAttrs;
+type InstaQLEntity<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, EntityName extends keyof Schema['entities'], Subquery extends InstaQLEntitySubquery<Schema, EntityName> | undefined = {}, Fields extends InstaQLFields<Schema, EntityName> | undefined = undefined, UseDates extends boolean = false> = Expand<{
+    id: string;
+} & ComputeAttrs<ResolveEntityAttrs<Schema['entities'][EntityName], UseDates>, Fields> & InstaQLEntitySubqueryResult<Schema, EntityName, Subquery, UseDates>>;
+export type InstaQLQueryEntityResult<Entities extends EntitiesDef, EntityName extends keyof Entities, Query extends {
+    [QueryPropName in keyof Entities[EntityName]['links']]?: any;
+}, WithCardinalityInference extends boolean, UseDates extends boolean> = {
+    id: string;
+} & ResolveAttrs<Entities, EntityName, UseDates> & InstaQLQueryEntityLinksResult<Entities, EntityName, Query, WithCardinalityInference, UseDates>;
+type InstaQLQueryResult<Entities extends EntitiesDef, Query, WithCardinalityInference extends boolean, UseDates extends boolean> = {
+    [QueryPropName in keyof Query]: QueryPropName extends keyof Entities ? InstaQLQueryEntityResult<Entities, QueryPropName, Query[QueryPropName], WithCardinalityInference, UseDates>[] : never;
+};
+type InstaQLResult<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Query extends InstaQLParams<Schema> | undefined, UseDates extends boolean = false> = Expand<{
+    [QueryPropName in keyof Query]: QueryPropName extends keyof Schema['entities'] ? InstaQLEntity<Schema, QueryPropName, Remove$NonRecursive<SafeLookup<Query, [QueryPropName]>>, SafeLookup<Query, [QueryPropName, '$', 'fields']>, UseDates>[] : never;
+}>;
+type InstaQLEntitySubquery<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, EntityName extends keyof Schema['entities']> = {
+    [QueryPropName in keyof Schema['entities'][EntityName]['links']]?: $Option<Schema, EntityName> | ($Option<Schema, EntityName> & InstaQLEntitySubquery<Schema, Schema['entities'][EntityName]['links'][QueryPropName]['entityName']>);
+};
+type InstaQLQuerySubqueryParams<S extends IContainEntitiesAndLinks<any, any>, E extends keyof S['entities']> = {
+    [K in keyof S['entities'][E]['links']]?: $Option<S, S['entities'][E]['links'][K]['entityName']> | ($Option<S, S['entities'][E]['links'][K]['entityName']> & InstaQLQuerySubqueryParams<S, S['entities'][E]['links'][K]['entityName']>);
+};
+type InstaQLParams<S extends IContainEntitiesAndLinks<any, any>> = {
+    [K in keyof S['entities']]?: $Option<S, K> | ($Option<S, K> & InstaQLQuerySubqueryParams<S, K>);
+};
+/**
+ * @deprecated
+ * `InstaQLQueryParams` is deprecated. Use `InstaQLParams` instead.
+ *
+ * @example
+ * // Before
+ * const myQuery = {...} satisfies InstaQLQueryParams<Schema>
+ * // After
+ * const myQuery = {...} satisfies InstaQLParams<Schema>
+ */
+type InstaQLQueryParams<S extends IContainEntitiesAndLinks<any, any>> = InstaQLParams<S>;
+type InstaQLOptions = {
+    ruleParams: RuleParams;
+};
+type ValidQueryObject<T extends Record<string, any>, Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities'], TopLevel extends boolean> = keyof T extends keyof Schema['entities'][EntityName]['links'] | '$' ? {
+    [K in keyof Schema['entities'][EntityName]['links']]?: ValidQueryObject<T[K], Schema, Schema['entities'][EntityName]['links'][K]['entityName'], false>;
+} & {
+    $?: ValidDollarSignQuery<T['$'], Schema, EntityName, TopLevel>;
+} : never;
+type PaginationKeys = 'limit' | 'last' | 'first' | 'offset' | 'after' | 'afterInclusive' | 'before' | 'beforeInclusive';
+type AllowedDollarSignKeys<TopLevel extends boolean> = TopLevel extends true ? PaginationKeys | 'where' | 'fields' | 'order' : 'where' | 'fields' | 'order' | 'limit';
+type ValidFieldNames<S extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof S['entities']> = Extract<keyof ResolveEntityAttrs<S['entities'][EntityName]>, string> | 'id';
+type ValidDollarSignQuery<Input extends {
+    [key: string]: any;
+}, Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities'], TopLevel extends boolean> = keyof Input extends AllowedDollarSignKeys<TopLevel> ? {
+    where?: ValidWhereObject<Input['where'], Schema, EntityName>;
+    fields?: ValidFieldNames<Schema, EntityName>[];
+    order?: Order<Schema, EntityName>;
+    limit?: number;
+} & (TopLevel extends true ? {
+    last?: number;
+    first?: number;
+    offset?: number;
+    after?: Cursor;
+    afterInclusive?: boolean;
+    before?: Cursor;
+    beforeInclusive?: boolean;
+} : {}) : never;
+type StringifiableKey<T> = Extract<T, string | number | bigint | boolean>;
+type ValidWhereNestedPath<T, K extends string | number | symbol, Schema extends IContainEntitiesAndLinks<any, any>> = T extends object ? K extends keyof T ? K : K extends `${infer K0}.${infer KR}` ? K0 extends keyof T ? T[K0] extends keyof Schema['entities'] ? `${K0}.${ValidWhereNestedPath<{
+    [K in keyof Schema['entities'][T[K0]]['links']]: Schema['entities'][T[K0]]['links'][K]['entityName'];
+}, KR, Schema> | StringifiableKey<keyof Schema['entities'][T[K0]]['attrs']> | 'id'}` : string & keyof T : string & keyof T : string & keyof T : never;
+type ValidDotPath<Input extends string | number | symbol, Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities']> = ValidWhereNestedPath<{
+    [K in keyof Schema['entities'][EntityName]['links']]: Schema['entities'][EntityName]['links'][K]['entityName'];
+}, Input, Schema>;
+type WhereOperatorObject<Input, V, R, I> = keyof Input extends keyof BaseWhereClauseValueComplex<V> | '$ilike' | '$like' | '$isNull' ? BaseWhereClauseValueComplex<V> & (IsAny<V> extends true ? {
+    $ilike?: string;
+    $like?: string;
+    $isNull?: boolean;
+} : (V extends string ? {
+    $like?: string;
+} : {}) & (R extends false ? {
+    $isNull?: boolean;
+} : {}) & (I extends true ? {
+    $ilike?: string;
+} : {})) : never;
+type ValidWhereValue<Input, AttrDef extends DataAttrDef<any, any, any, boolean>> = AttrDef extends DataAttrDef<infer V, infer R, infer I, boolean> ? Input extends V ? V : NonEmpty<WhereOperatorObject<Input, V, R, I>> : never;
+type NoDistribute<T> = [T] extends [any] ? T : never;
+type ValidWhereObject<Input extends {
+    [key: string]: any;
+} | undefined, Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities']> = Input extends undefined ? undefined : keyof Input extends ValidDotPath<keyof Input, Schema, EntityName> | keyof Schema['entities'][EntityName]['attrs'] | 'and' | 'or' | 'id' ? {
+    [K in ValidDotPath<keyof Input, Schema, EntityName>]?: ValidWhereValue<Input[K], ExtractAttrFromDotPath<K, Schema, EntityName>>;
+} & {
+    [K in keyof Schema['entities'][EntityName]['attrs']]?: ValidWhereValue<Input[K], Schema['entities'][EntityName]['attrs'][K]>;
+} & {
+    and?: Input extends {
+        and: Array<infer Item extends {
+            [key: string]: any;
+        } | undefined>;
+    } ? ValidWhereObject<NoDistribute<Item>, Schema, EntityName>[] : never;
+    or?: Input extends {
+        or: Array<infer Item extends {
+            [key: string]: any;
+        } | undefined>;
+    } ? ValidWhereObject<NoDistribute<Item>, Schema, EntityName>[] : never;
+} & {
+    id?: ValidWhereValue<SafeLookup<Input, ['id']>, DataAttrDef<string, false, false, boolean>>;
+} : never;
+/**
+ * Extracts the attribute definition from a valid dot path.
+ * Given a dot path like "user.posts.title", this will resolve to the type of the "title" attribute.
+ * If the path is just a link name (e.g., "posts"), it defaults to the id field.
+ * Returns DataAttrDef or never
+ */
+type ExtractAttrFromDotPath<Path extends string | number | symbol, Schema extends IContainEntitiesAndLinks<any, any>, EntityName extends keyof Schema['entities']> = Path extends keyof Schema['entities'][EntityName]['attrs'] ? Schema['entities'][EntityName]['attrs'][Path] : Path extends 'id' ? DataAttrDef<string, false, false, boolean> : Path extends `${infer LinkName}.${infer RestPath}` ? LinkName extends keyof Schema['entities'][EntityName]['links'] ? ExtractAttrFromDotPath<RestPath, Schema, Schema['entities'][EntityName]['links'][LinkName]['entityName']> : never : Path extends keyof Schema['entities'][EntityName]['links'] ? DataAttrDef<string, false, false, boolean> : never;
+type ValidQuery<Q extends Record<string, any>, S extends IContainEntitiesAndLinks<any, any>> = S extends InstantUnknownSchemaDef ? InstaQLParams<S> : keyof Q extends keyof S['entities'] ? {
+    [K in keyof S['entities']]?: ValidQueryObject<Q[K], S, K, true>;
+} : never;
+export { Query, QueryResponse, InstaQLResponse, PageInfoResponse, InstantObject, Exactly, Remove$, ValidQuery, InstaQLQueryResult, InstaQLParams, InstaQLOptions, InstaQLEntitySubquery, InstaQLEntity, InstaQLResult, InstaQLFields, Cursor, InstaQLQueryParams, };

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

@@ -0,0 +1,3 @@
+// Query
+// -----
+export {};

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

@@ -0,0 +1,5 @@
+import { IContainEntitiesAndLinks } from './schemaTypes.ts';
+export declare class QueryValidationError extends Error {
+    constructor(message: string, path?: string);
+}
+export declare const validateQuery: (q: unknown, schema?: IContainEntitiesAndLinks<any, any>) => void;

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

@@ -0,0 +1,287 @@
+import { DataAttrDef, } from './schemaTypes.js';
+import { validate as validateUUID } from 'uuid';
+export class QueryValidationError extends Error {
+    constructor(message, path) {
+        const fullMessage = path ? `At path '${path}': ${message}` : message;
+        super(fullMessage);
+        this.name = 'QueryValidationError';
+    }
+}
+const dollarSignKeys = [
+    'where',
+    'order',
+    'limit',
+    'last',
+    'first',
+    'offset',
+    'after',
+    'afterInclusive',
+    'before',
+    'beforeInclusive',
+    'fields',
+    'aggregate',
+];
+const getAttrType = (attrDef) => {
+    return attrDef.valueType || 'unknown';
+};
+const isValidValueForType = (value, expectedType, isAnyType = false) => {
+    if (isAnyType)
+        return true;
+    if (value === null || value === undefined)
+        return true;
+    switch (expectedType) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && !isNaN(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'date':
+            return (value instanceof Date ||
+                typeof value === 'string' ||
+                typeof value === 'number');
+        default:
+            return true;
+    }
+};
+const validateOperator = (op, opValue, expectedType, attrName, entityName, attrDef, path) => {
+    const isAnyType = attrDef.valueType === 'json';
+    const assertValidValue = (op, expectedType, opValue) => {
+        if (!isValidValueForType(opValue, expectedType, isAnyType)) {
+            throw new QueryValidationError(`Invalid value for operator '${op}' on attribute '${attrName}' in entity '${entityName}'. Expected ${expectedType}, but received: ${typeof opValue}`, path);
+        }
+    };
+    switch (op) {
+        case 'in':
+        case '$in':
+            if (!Array.isArray(opValue)) {
+                throw new QueryValidationError(`Operator '${op}' for attribute '${attrName}' in entity '${entityName}' must be an array, but received: ${typeof opValue}`, path);
+            }
+            for (const item of opValue) {
+                assertValidValue(op, expectedType, item);
+            }
+            break;
+        case '$not':
+        case '$ne':
+        case '$gt':
+        case '$lt':
+        case '$gte':
+        case '$lte':
+            assertValidValue(op, expectedType, opValue);
+            break;
+        case '$like':
+        case '$ilike':
+            assertValidValue(op, 'string', opValue);
+            if (op === '$ilike') {
+                if (!attrDef.isIndexed) {
+                    throw new QueryValidationError(`Operator '${op}' can only be used with indexed attributes, but '${attrName}' in entity '${entityName}' is not indexed`, path);
+                }
+            }
+            break;
+        case '$isNull':
+            assertValidValue(op, 'boolean', opValue);
+            break;
+        default:
+            throw new QueryValidationError(`Unknown operator '${op}' for attribute '${attrName}' in entity '${entityName}'`, path);
+    }
+};
+const validateWhereClauseValue = (value, attrName, attrDef, entityName, path) => {
+    const expectedType = getAttrType(attrDef);
+    const isAnyType = attrDef.valueType === 'json';
+    const isComplexObject = typeof value === 'object' && value !== null && !Array.isArray(value);
+    if (isComplexObject) {
+        // For any type, allow complex objects without treating them as operators
+        if (isAnyType) {
+            return; // Any type accepts any value, including complex objects
+        }
+        const operators = value;
+        for (const [op, opValue] of Object.entries(operators)) {
+            validateOperator(op, opValue, expectedType, attrName, entityName, attrDef, `${path}.${op}`);
+        }
+    }
+    else {
+        if (!isValidValueForType(value, expectedType, isAnyType)) {
+            throw new QueryValidationError(`Invalid value for attribute '${attrName}' in entity '${entityName}'. Expected ${expectedType}, but received: ${typeof value}`, path);
+        }
+    }
+};
+const validateDotNotationAttribute = (dotPath, value, startEntityName, schema, path) => {
+    const pathParts = dotPath.split('.');
+    if (pathParts.length < 2) {
+        throw new QueryValidationError(`Invalid dot notation path '${dotPath}'. Must contain at least one dot.`, path);
+    }
+    let currentEntityName = startEntityName;
+    // Traverse all path parts except the last one (which should be an attribute)
+    for (let i = 0; i < pathParts.length - 1; i++) {
+        const linkName = pathParts[i];
+        const currentEntity = schema.entities[currentEntityName];
+        if (!currentEntity) {
+            throw new QueryValidationError(`Entity '${currentEntityName}' does not exist in schema while traversing dot notation path '${dotPath}'.`, path);
+        }
+        const link = currentEntity.links[linkName];
+        if (!link) {
+            const availableLinks = Object.keys(currentEntity.links);
+            throw new QueryValidationError(`Link '${linkName}' does not exist on entity '${currentEntityName}' in dot notation path '${dotPath}'. Available links: ${availableLinks.length > 0 ? availableLinks.join(', ') : 'none'}`, path);
+        }
+        currentEntityName = link.entityName;
+    }
+    // Validate the final attribute
+    const finalAttrName = pathParts[pathParts.length - 1];
+    const finalEntity = schema.entities[currentEntityName];
+    if (!finalEntity) {
+        throw new QueryValidationError(`Target entity '${currentEntityName}' does not exist in schema for dot notation path '${dotPath}'.`, path);
+    }
+    // Handle 'id' field specially - every entity has an id field
+    if (finalAttrName === 'id') {
+        if (typeof value == 'string' && !validateUUID(value)) {
+            throw new QueryValidationError(`Invalid value for id field in entity '${currentEntityName}'. Expected a UUID, but received: ${value}`, path);
+        }
+        validateWhereClauseValue(value, dotPath, new DataAttrDef('string', false, true), startEntityName, path);
+        return;
+    }
+    const attrDef = finalEntity.attrs[finalAttrName];
+    if (Object.keys(finalEntity.links).includes(finalAttrName)) {
+        if (typeof value === 'string' && !validateUUID(value)) {
+            throw new QueryValidationError(`Invalid value for link '${finalAttrName}' in entity '${currentEntityName}'. Expected a UUID, but received: ${value}`, path);
+        }
+        validateWhereClauseValue(value, dotPath, new DataAttrDef('string', false, true), startEntityName, path);
+        return;
+    }
+    if (!attrDef) {
+        const availableAttrs = Object.keys(finalEntity.attrs);
+        throw new QueryValidationError(`Attribute '${finalAttrName}' does not exist on entity '${currentEntityName}' in dot notation path '${dotPath}'. Available attributes: ${availableAttrs.length > 0 ? availableAttrs.join(', ') + ', id' : 'id'}`, path);
+    }
+    // Validate the value against the attribute type
+    validateWhereClauseValue(value, dotPath, attrDef, startEntityName, path);
+};
+const validateWhereClause = (whereClause, entityName, schema, path) => {
+    for (const [key, value] of Object.entries(whereClause)) {
+        if (key === 'or' || key === 'and') {
+            if (Array.isArray(value)) {
+                for (const clause of value) {
+                    if (typeof clause === 'object' && clause !== null) {
+                        validateWhereClause(clause, entityName, schema, `${path}.${key}[${clause}]`);
+                    }
+                }
+            }
+            continue;
+        }
+        if (key === 'id') {
+            validateWhereClauseValue(value, 'id', new DataAttrDef('string', false, true), entityName, `${path}.id`);
+            continue;
+        }
+        if (key.includes('.')) {
+            validateDotNotationAttribute(key, value, entityName, schema, `${path}.${key}`);
+            continue;
+        }
+        const entityDef = schema.entities[entityName];
+        if (!entityDef)
+            continue;
+        const attrDef = entityDef.attrs[key];
+        const linkDef = entityDef.links[key];
+        if (!attrDef && !linkDef) {
+            const availableAttrs = Object.keys(entityDef.attrs);
+            const availableLinks = Object.keys(entityDef.links);
+            throw new QueryValidationError(`Attribute or link '${key}' does not exist on entity '${entityName}'. Available attributes: ${availableAttrs.length > 0 ? availableAttrs.join(', ') : 'none'}. Available links: ${availableLinks.length > 0 ? availableLinks.join(', ') : 'none'}`, `${path}.${key}`);
+        }
+        if (attrDef) {
+            validateWhereClauseValue(value, key, attrDef, entityName, `${path}.${key}`);
+        }
+        else if (linkDef) {
+            // For links, we expect the value to be a string (ID of the linked entity)
+            // Create a synthetic string attribute definition for validation
+            if (typeof value === 'string' && !validateUUID(value)) {
+                throw new QueryValidationError(`Invalid value for link '${key}' in entity '${entityName}'. Expected a UUID, but received: ${value}`, `${path}.${key}`);
+            }
+            const syntheticAttrDef = new DataAttrDef('string', false, true);
+            validateWhereClauseValue(value, key, syntheticAttrDef, entityName, `${path}.${key}`);
+        }
+    }
+};
+const validateDollarObject = (dollarObj, entityName, schema, path, depth = 0) => {
+    for (const key of Object.keys(dollarObj)) {
+        if (!dollarSignKeys.includes(key)) {
+            throw new QueryValidationError(`Invalid query parameter '${key}' in $ object. Valid parameters are: ${dollarSignKeys.join(', ')}. Found: ${key}`, path);
+        }
+    }
+    // Validate that pagination parameters are only used at top-level
+    const paginationParams = [
+        // 'limit', // only supported client side
+        'offset',
+        'before',
+        'beforeInclusive',
+        'after',
+        'afterInclusive',
+        'first',
+        'last',
+    ];
+    for (const param of paginationParams) {
+        if (dollarObj[param] !== undefined && depth > 0) {
+            throw new QueryValidationError(`'${param}' can only be used on top-level namespaces. It cannot be used in nested queries.`, path);
+        }
+    }
+    if (dollarObj.where && schema) {
+        if (typeof dollarObj.where !== 'object' || dollarObj.where === null) {
+            throw new QueryValidationError(`'where' clause must be an object in entity '${entityName}', but received: ${typeof dollarObj.where}`, path ? `${path}.where` : undefined);
+        }
+        validateWhereClause(dollarObj.where, entityName, schema, path ? `${path}.where` : 'where');
+    }
+};
+const validateEntityInQuery = (queryPart, entityName, schema, path, depth = 0) => {
+    if (!queryPart || typeof queryPart !== 'object') {
+        throw new QueryValidationError(`Query part for entity '${entityName}' must be an object, but received: ${typeof queryPart}`, path);
+    }
+    for (const key of Object.keys(queryPart)) {
+        if (key !== '$') {
+            // Validate link exists
+            if (schema && !(key in schema.entities[entityName].links)) {
+                const availableLinks = Object.keys(schema.entities[entityName].links);
+                throw new QueryValidationError(`Link '${key}' does not exist on entity '${entityName}'. Available links: ${availableLinks.length > 0 ? availableLinks.join(', ') : 'none'}`, `${path}.${key}`);
+            }
+            // Recursively validate nested query
+            const nestedQuery = queryPart[key];
+            if (typeof nestedQuery === 'object' && nestedQuery !== null) {
+                const linkedEntityName = schema?.entities[entityName].links[key]?.entityName;
+                if (linkedEntityName) {
+                    validateEntityInQuery(nestedQuery, linkedEntityName, schema, `${path}.${key}`, depth + 1);
+                }
+            }
+        }
+        else {
+            // Validate $ object
+            const dollarObj = queryPart[key];
+            if (typeof dollarObj !== 'object' || dollarObj === null) {
+                throw new QueryValidationError(`Query parameter '$' must be an object in entity '${entityName}', but received: ${typeof dollarObj}`, `${path}.$`);
+            }
+            validateDollarObject(dollarObj, entityName, schema, `${path}.$`, depth);
+        }
+    }
+};
+export const validateQuery = (q, schema) => {
+    if (typeof q !== 'object' || q === null) {
+        throw new QueryValidationError(`Query must be an object, but received: ${typeof q}${q === null ? ' (null)' : ''}`);
+    }
+    if (Array.isArray(q)) {
+        throw new QueryValidationError(`Query must be an object, but received: ${typeof q}`);
+    }
+    const queryObj = q;
+    for (const topLevelKey of Object.keys(queryObj)) {
+        if (Array.isArray(q[topLevelKey])) {
+            throw new QueryValidationError(`Query keys must be strings, but found key of type: ${typeof topLevelKey}`, topLevelKey);
+        }
+        if (typeof topLevelKey !== 'string') {
+            throw new QueryValidationError(`Query keys must be strings, but found key of type: ${typeof topLevelKey}`, topLevelKey);
+        }
+        if (topLevelKey === '$$ruleParams') {
+            continue;
+        }
+        // Check if the key is top level entity
+        if (schema) {
+            if (!schema.entities[topLevelKey]) {
+                const availableEntities = Object.keys(schema.entities);
+                throw new QueryValidationError(`Entity '${topLevelKey}' does not exist in schema. Available entities: ${availableEntities.length > 0 ? availableEntities.join(', ') : 'none'}`, topLevelKey);
+            }
+        }
+        validateEntityInQuery(queryObj[topLevelKey], topLevelKey, schema, topLevelKey, 0);
+    }
+};

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

@@ -0,0 +1,29 @@
+import { PageInfoResponse } from './queryTypes.ts';
+import { AttrsStore, AttrsStoreJson, Store, StoreJson } from './store.ts';
+export type QuerySubResult = {
+    store: Store;
+    attrsStore: AttrsStore;
+    pageInfo?: PageInfoResponse<any> | null | undefined;
+    aggregate?: any;
+    processedTxId?: number;
+    isExternal?: boolean;
+};
+export type QuerySub = {
+    q: Object;
+    eventId?: string;
+    lastAccessed?: number | null | undefined;
+    result?: QuerySubResult;
+};
+export type QuerySubResultInStorage = {
+    store: StoreJson;
+    attrsStore: AttrsStoreJson;
+    pageInfo?: PageInfoResponse<any> | null | undefined;
+    aggregate?: any;
+    processedTxId?: number;
+};
+export type QuerySubInStorage = {
+    q: Object;
+    eventId?: string;
+    lastAccessed?: number | null | undefined;
+    result?: QuerySubResultInStorage;
+};

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

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

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

@@ -0,0 +1,19 @@
+import type { User } from './clientTypes.ts';
+/**
+ * Known payloads sent to `firstPartyPath` and handled by
+ * `createInstantRouteHandler`.
+ */
+export type InstantRouteHandlerPayloadByType = {
+    'sync-user': {
+        appId: string;
+        user: User | null;
+    };
+};
+/** Known `type` values for Instant route handler request bodies. */
+export type InstantRouteHandlerType = keyof InstantRouteHandlerPayloadByType;
+/** A valid request body for Instant's first-party route handler protocol. */
+export type InstantRouteHandlerBody<Type extends InstantRouteHandlerType = InstantRouteHandlerType> = {
+    [KnownType in Type]: {
+        type: KnownType;
+    } & InstantRouteHandlerPayloadByType[KnownType];
+}[Type];

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

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