@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,85 @@
+import { InstantSchemaDef, InstantUnknownSchema } from './schemaTypes.ts';
+type InstantRulesAttrsAllowBlock = {
+    $default?: string | null | undefined;
+    view?: string | null | undefined;
+    create?: string | null | undefined;
+    update?: string | null | undefined;
+    delete?: string | null | undefined;
+};
+export type InstantRulesAllowBlock = InstantRulesAttrsAllowBlock & {
+    link?: {
+        [key: string]: string;
+    } | null | undefined;
+    unlink?: {
+        [key: string]: string;
+    } | null | undefined;
+};
+/**
+ * How tokens refill in a rate limit bucket.
+ * - `'greedy'`: tokens trickle in continuously over the period.
+ * - `'interval'`: all tokens are added at once when the period elapses.
+ */
+export type InstantRulesRateLimitRefillType = 'interval' | 'greedy';
+/**
+ * Configuration for how a rate limit bucket refills.
+ * All fields are optional and have sensible defaults.
+ */
+export type InstantRulesRateLimitRefill = {
+    /** Number of tokens added per refill. Defaults to the bucket's capacity. */
+    amount?: number | null | undefined;
+    /**
+     * How often tokens refill, as a duration string (e.g. `"1 hour"`, `"30 minutes"`, `"1 day"`).
+     * Must be between 1 second and 24 hours. Defaults to `"1 hour"`.
+     */
+    period?: string | null | undefined;
+    /** Refill strategy. Defaults to `"greedy"`. */
+    type?: InstantRulesRateLimitRefillType | null | undefined;
+};
+/**
+ * A single rate limit within a bucket. Each limit represents one token bucket
+ * constraint. You can combine multiple limits (e.g. a burst limit and a sustained limit).
+ */
+export type InstantRulesRateLimitLimit = {
+    /** Maximum number of tokens in the bucket. */
+    capacity: number;
+    /** Refill configuration. Defaults to greedy refill of the full capacity every hour. */
+    refill?: InstantRulesRateLimitRefill | null | undefined;
+};
+/**
+ * A named rate limit bucket configuration. Use in permission rules via
+ * `rateLimit.bucketName.limit(key)`.
+ */
+export type InstantRulesRateLimit = {
+    /** One or more token bucket limits to apply. */
+    limits: Array<InstantRulesRateLimitLimit>;
+};
+/**
+ * Map of rate limit names to their configurations.
+ * Defined under the `$rateLimits` key in your permission rules.
+ */
+export type InstantRulesRateLimits = Record<string, InstantRulesRateLimit>;
+type InstantRulesEntityBlock<Schema extends InstantSchemaDef<any, any, any>, EntityName extends keyof Schema['entities']> = {
+    bind?: string[] | Record<string, string>;
+    allow: InstantRulesAllowBlock;
+    fields?: {
+        [AttrName in Exclude<keyof Schema['entities'][EntityName]['attrs'], 'id'>]?: string;
+    };
+};
+export type InstantRules<Schema extends InstantSchemaDef<any, any, any> = InstantUnknownSchema> = {
+    [K in 'attrs' | '$default' | '$rateLimits']?: K extends 'attrs' ? {
+        bind?: string[] | Record<string, string>;
+        allow: InstantRulesAttrsAllowBlock;
+    } : K extends '$default' ? {
+        bind?: string[] | Record<string, string>;
+        allow: InstantRulesAllowBlock;
+    } : K extends '$rateLimits' ? InstantRulesRateLimits : never;
+} & {
+    [K in keyof Schema['entities'] | 'attrs' | '$default' | '$rateLimits']?: K extends 'attrs' ? {
+        bind?: string[] | Record<string, string>;
+        allow: InstantRulesAttrsAllowBlock;
+    } : K extends '$default' ? {
+        bind?: string[] | Record<string, string>;
+        allow: InstantRulesAllowBlock;
+    } : K extends '$rateLimits' ? InstantRulesRateLimits : K extends keyof Schema['entities'] ? InstantRulesEntityBlock<Schema, K> : never;
+};
+export {};

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

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

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

@@ -0,0 +1,18 @@
+import type { InstaQLResponse, ValidQuery } from './queryTypes.ts';
+import { InstantUnknownSchema } from './schemaTypes.ts';
+/**
+ * The purpose of these sanity checks:
+ * If we make changes and something breaks, our build will fail.
+ *
+ * AFAIK we _could_ write this in our `tests` folder.
+ * The latest version of `vitest` does support `assertType`, but:
+ *  * it's easy to get false positives if configured incorrectly
+ *  * the api is more vebose than this
+ */
+export declare function dummyQuery<Q extends ValidQuery<Q, InstantUnknownSchema>>(_query: Q): InstaQLResponse<InstantUnknownSchema, Q>;
+export interface ExUser {
+    name: string;
+}
+export interface ExPost {
+    title: string;
+}

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

@@ -0,0 +1,152 @@
+// --------
+// Sanity check tests
+/**
+ * The purpose of these sanity checks:
+ * If we make changes and something breaks, our build will fail.
+ *
+ * AFAIK we _could_ write this in our `tests` folder.
+ * The latest version of `vitest` does support `assertType`, but:
+ *  * it's easy to get false positives if configured incorrectly
+ *  * the api is more vebose than this
+ */
+export function dummyQuery(_query) {
+    return 1;
+}
+const sanityCheckQueries = () => {
+    // -----------
+    // Basic good inputs succeed
+    const r = dummyQuery({ users: {} });
+    // -----------
+    // Basic bad inputs fails
+    // @ts-expect-error
+    const r2 = dummyQuery({ users: 1 });
+    // @ts-expect-error
+    const r3 = dummyQuery({ users: '' });
+    // ----------------------
+    // Good $ clauses succeed
+    const r4 = dummyQuery({ users: { $: { where: { foo: 1 } } } });
+    const r5 = dummyQuery({ users: { $: { where: { foo: 'str' } } } });
+    const r6 = dummyQuery({ users: { $: { where: { foo: true } } } });
+    const r7 = dummyQuery({ users: { $: { where: { 'foo.bar.baz': 1 } } } });
+    const s1 = dummyQuery({
+        users: { $: { where: { foo: { in: [1, 2, 3] } } } },
+    });
+    const s1_5 = dummyQuery({
+        users: { $: { where: { foo: { $in: [1, 2, 3] } } } },
+    });
+    const t1 = dummyQuery({
+        users: { $: { where: { or: [{ foo: 1 }] } } },
+    });
+    // You can have a field named or
+    const t2 = dummyQuery({
+        users: { $: { where: { or: 'fieldNamedOr' } } },
+    });
+    const t3 = dummyQuery({
+        users: { $: { where: { and: [{ foo: 1 }] } } },
+    });
+    // You can have a field named and
+    const t4 = dummyQuery({
+        users: { $: { where: { and: 'fieldNamedAnd' } } },
+    });
+    const t5 = dummyQuery({
+        users: { $: { where: { and: [{ or: [{ foo: 1 }] }] } } },
+    });
+    // Pagination
+    const t6 = dummyQuery({
+        users: { $: { limit: 10 } },
+    });
+    const t7 = dummyQuery({
+        users: { $: { limit: 10, offset: 10 } },
+    });
+    const t8 = dummyQuery({
+        users: { $: { where: { foo: 1 }, limit: 10, offset: 10 } },
+    });
+    const cursor = [
+        '61935703-bec6-4ade-ad9b-8bf382b92f69',
+        '995f5a9b-9ae1-4e59-97d1-df33afb44aee',
+        '61935703-bec6-4ade-ad9b-8bf382b92f69',
+        10,
+    ];
+    const t9 = dummyQuery({
+        users: {
+            $: { where: { foo: 1 }, after: cursor },
+        },
+    });
+    const t10 = dummyQuery({
+        users: { $: { before: cursor } },
+    });
+    const t12 = dummyQuery({
+        users: { $: { where: { val: { $isNull: true } } } },
+    });
+    const t13 = dummyQuery({
+        users: { $: { where: { val: { $not: 'a' } } } },
+    });
+    const t14 = dummyQuery({
+        users: {
+            $: { fields: ['name', 'age', 'dob'] },
+            posts: { $: { fields: ['title'] } },
+        },
+    });
+    // ------------------
+    // Bad $ clauses fail
+    // @ts-expect-error
+    const r8 = dummyQuery({ users: { $: { where: 'foo' } } });
+    // #ts-expect-error
+    const r9 = dummyQuery({ users: { $: { where: { foo: {} } } } });
+    // @ts-expect-error
+    const r10 = dummyQuery({ users: { $: { where2: 1 } } });
+    const s2 = dummyQuery({
+        // #ts-expect-error
+        users: { $: { where: { foo: { ini: [1, 2, 3] } } } },
+    });
+    const s3 = dummyQuery({
+        // #ts-expect-error
+        users: { $: { where: { foo: [] } } },
+    });
+    const s4 = dummyQuery({
+        // #ts-expect-error
+        users: { $: { where: { val: { $isNull: 'a' } } } },
+    });
+    const s5 = dummyQuery({
+        // @ts-expect-error
+        users: { $: { where: { 'josijf.jsdfli': { $isNull: 'a' } } } },
+    });
+    // NOTE: Used to error before adding typesafe-where operator, issue is incompatibility
+    // with NonEmpty and dynamic $isNull checks
+    const s6 = dummyQuery({
+        users: { $: { where: { val: { $gt: { val: 'a' } } } } },
+    });
+    // ----------------
+    // Good Nested queries succeed
+    const r11 = dummyQuery({ users: { posts: {} } });
+    const r12 = dummyQuery({ users: {}, posts: {} });
+    const r13 = dummyQuery({
+        users: {
+            $: { where: { foo: 1 } },
+            posts: { $: { where: { foo: 1 } } },
+        },
+    });
+    // ----------
+    // Bad nested queries fail
+    // #ts-expect-error
+    const r14 = dummyQuery({ users: { foo: 1 } });
+    const r15 = dummyQuery({
+        // @ts-expect-error
+        users: { $: { fields: 'name' } },
+    });
+};
+const sanityCheckSchemalessResponses = () => {
+    // Simple Response
+    const r1 = dummyQuery({ users: {} });
+    // Nested Response
+    const r2 = dummyQuery({ users: { posts: {} } });
+    // $ are ignored
+    const r3 = dummyQuery({
+        users: {
+            $: { where: { foo: 1 } },
+            posts: {},
+        },
+    });
+    // @ts-expect-error
+    r3.$;
+};

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

@@ -0,0 +1,72 @@
+import { EntityDef, DataAttrDef, InstantSchemaDef, type EntitiesDef, type AttrsDefs, type EntitiesWithLinks, type LinksDef, type RoomsDef, type UnknownRooms } from './schemaTypes.ts';
+/**
+ * @deprecated
+ * `i.graph` is deprecated. Use `i.schema` instead.
+ *
+ * @example
+ * // Before
+ * i.graph(entities, links).withRoomSchema<RoomType>();
+ *
+ * // After
+ * i.schema({ entities, links, rooms })
+ *
+ * @see
+ * https://instantdb.com/docs/modeling-data
+ */
+declare function graph<EntitiesWithoutLinks extends EntitiesDef, const Links extends LinksDef<EntitiesWithoutLinks>>(entities: EntitiesWithoutLinks, links: Links): InstantSchemaDef<EntitiesWithLinks<EntitiesWithoutLinks, Links>, LinksDef<any>, UnknownRooms>;
+/**
+ * Creates an entity definition, to be used in conjunction with `i.graph`.
+ *
+ * @see https://instantdb.com/docs/modeling-data
+ * @example
+ *   {
+ *     posts: i.entity({
+ *       title: i.string(),
+ *       body: i.string(),
+ *     }),
+ *     comments: i.entity({
+ *       body: i.string(),
+ *     })
+ *   }
+ */
+declare function entity<Attrs extends AttrsDefs>(attrs: Attrs): EntityDef<Attrs, {}, void>;
+declare function string<StringEnum extends string = string>(): DataAttrDef<StringEnum, true, false>;
+declare function number(): DataAttrDef<number, true, false>;
+declare function boolean(): DataAttrDef<boolean, true, false>;
+declare function date(): DataAttrDef<Date, true, false>;
+declare function json<T = any>(): DataAttrDef<T, true, false>;
+declare function any(): DataAttrDef<any, true, false>;
+/**
+ * Lets you define a schema for your database.
+ *
+ * You can define entities, links between entities, and if you use
+ * presence, you can define rooms.
+ *
+ * You can push this schema to your database with the CLI,
+ * or use it inside `init`, to get typesafety and autocompletion.
+ *
+ * @see https://instantdb.com/docs/modeling-data
+ * @example
+ *   i.schema({
+ *     entities: { },
+ *     links: { },
+ *     rooms: { }
+ *   });
+ */
+declare function schema<EntitiesWithoutLinks extends EntitiesDef, const Links extends LinksDef<EntitiesWithoutLinks>, Rooms extends RoomsDef = {}>({ entities, links, rooms, }: {
+    entities: EntitiesWithoutLinks;
+    links?: Links;
+    rooms?: Rooms;
+}): InstantSchemaDef<EntitiesWithLinks<EntitiesWithoutLinks, Links>, LinksDef<any>, Rooms>;
+export declare const i: {
+    graph: typeof graph;
+    schema: typeof schema;
+    entity: typeof entity;
+    string: typeof string;
+    number: typeof number;
+    boolean: typeof boolean;
+    date: typeof date;
+    json: typeof json;
+    any: typeof any;
+};
+export {};

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

@@ -0,0 +1,128 @@
+import { EntityDef, DataAttrDef, InstantSchemaDef, } from './schemaTypes.js';
+// ==========
+// API
+/**
+ * @deprecated
+ * `i.graph` is deprecated. Use `i.schema` instead.
+ *
+ * @example
+ * // Before
+ * i.graph(entities, links).withRoomSchema<RoomType>();
+ *
+ * // After
+ * i.schema({ entities, links, rooms })
+ *
+ * @see
+ * https://instantdb.com/docs/modeling-data
+ */
+function graph(entities, links) {
+    return new InstantSchemaDef(enrichEntitiesWithLinks(entities, links), 
+    // (XXX): LinksDef<any> stems from TypeScript’s inability to reconcile the
+    // type EntitiesWithLinks<EntitiesWithoutLinks, Links> with
+    // EntitiesWithoutLinks. TypeScript is strict about ensuring that types are
+    // correctly aligned and does not allow for substituting a type that might
+    // be broader or have additional properties.
+    links, undefined);
+}
+/**
+ * Creates an entity definition, to be used in conjunction with `i.graph`.
+ *
+ * @see https://instantdb.com/docs/modeling-data
+ * @example
+ *   {
+ *     posts: i.entity({
+ *       title: i.string(),
+ *       body: i.string(),
+ *     }),
+ *     comments: i.entity({
+ *       body: i.string(),
+ *     })
+ *   }
+ */
+function entity(attrs) {
+    return new EntityDef(attrs, {});
+}
+function string() {
+    return new DataAttrDef('string', true, false);
+}
+function number() {
+    return new DataAttrDef('number', true, false);
+}
+function boolean() {
+    return new DataAttrDef('boolean', true, false);
+}
+function date() {
+    return new DataAttrDef('date', true, false);
+}
+function json() {
+    return new DataAttrDef('json', true, false);
+}
+function any() {
+    return new DataAttrDef('json', true, false);
+}
+// ==========
+// internal
+function enrichEntitiesWithLinks(entities, links) {
+    const linksIndex = { fwd: {}, rev: {} };
+    for (const linkDef of Object.values(links)) {
+        linksIndex.fwd[linkDef.forward.on] ||= {};
+        linksIndex.rev[linkDef.reverse.on] ||= {};
+        linksIndex.fwd[linkDef.forward.on][linkDef.forward.label] = {
+            entityName: linkDef.reverse.on,
+            cardinality: linkDef.forward.has,
+        };
+        linksIndex.rev[linkDef.reverse.on][linkDef.reverse.label] = {
+            entityName: linkDef.forward.on,
+            cardinality: linkDef.reverse.has,
+        };
+    }
+    const enrichedEntities = Object.fromEntries(Object.entries(entities).map(([name, def]) => [
+        name,
+        new EntityDef(def.attrs, {
+            ...linksIndex.fwd[name],
+            ...linksIndex.rev[name],
+        }),
+    ]));
+    return enrichedEntities;
+}
+/**
+ * Lets you define a schema for your database.
+ *
+ * You can define entities, links between entities, and if you use
+ * presence, you can define rooms.
+ *
+ * You can push this schema to your database with the CLI,
+ * or use it inside `init`, to get typesafety and autocompletion.
+ *
+ * @see https://instantdb.com/docs/modeling-data
+ * @example
+ *   i.schema({
+ *     entities: { },
+ *     links: { },
+ *     rooms: { }
+ *   });
+ */
+function schema({ entities, links, rooms, }) {
+    const linksDef = (links ?? {});
+    const roomsDef = (rooms ?? {});
+    return new InstantSchemaDef(enrichEntitiesWithLinks(entities, linksDef), 
+    // (XXX): LinksDef<any> stems from TypeScript's inability to reconcile the
+    // type EntitiesWithLinks<EntitiesWithoutLinks, Links> with
+    // EntitiesWithoutLinks. TypeScript is strict about ensuring that types are
+    // correctly aligned and does not allow for substituting a type that might
+    // be broader or have additional properties.
+    linksDef, roomsDef);
+}
+export const i = {
+    // constructs
+    graph,
+    schema,
+    entity,
+    // value types
+    string,
+    number,
+    boolean,
+    date,
+    json,
+    any,
+};