ronin/dist/index-DqGaV9Ln.d.ts

Access your RONIN database via TypeScript.

import { QueryType, CombinedInstructions, Query, ResultRecord, Model, GetQuery, SetQuery, AddQuery, RemoveQuery, CountQuery, ListQuery, CreateQuery, AlterQuery, ModelField, ModelIndex, ModelPreset, DropQuery } from '@ronin/compiler';
import { DeepCallable } from '@ronin/syntax/queries';
import { Model as Model$1 } from '@ronin/syntax/schema';

interface TriggerOptions {
    /** Whether the query was generated implicitly by an trigger. */
    implicit: boolean;
    /** An instance of the current client, which can be used for nested queries. */
    client: ReturnType<typeof createSyntaxFactory>;
    /** The model for which the query is being executed. */
    model?: string;
    /** The database for which the query is being executed. */
    database?: string;
    /** A function for keeping the worker alive as long as a promise is not resolved. */
    waitUntil?: QueryHandlerOptions['waitUntil'];
}
type FilteredTriggerQuery<TType extends QueryType, TQuery extends CombinedInstructions = CombinedInstructions> = RecursivePartial<TQuery> & Pick<TQuery, TType extends 'count' ? never : TType extends 'add' ? 'to' : TType extends 'get' ? never : TType extends 'set' ? 'to' : TType extends 'remove' ? never : never>;
type BeforeTriggerHandler<TType extends QueryType, TQuery extends FilteredTriggerQuery<TType> = FilteredTriggerQuery<TType>> = (query: TQuery, multipleRecords: boolean, options: TriggerOptions) => Array<Query> | Promise<Array<Query>>;
type DuringTriggerHandler<TType extends QueryType, TQuery extends FilteredTriggerQuery<TType> = FilteredTriggerQuery<TType>> = (query: TQuery, multipleRecords: boolean, options: TriggerOptions) => TQuery | Promise<TQuery> | Query | Promise<Query>;
type AfterTriggerHandler<TType extends QueryType, TQuery extends FilteredTriggerQuery<TType> = FilteredTriggerQuery<TType>> = (query: TQuery, multipleRecords: boolean, options: TriggerOptions) => Array<Query> | Promise<Array<Query>>;
type ResolvingTriggerHandler<TType extends QueryType, TSchema = unknown> = (query: FilteredTriggerQuery<TType>, multipleRecords: boolean, options: TriggerOptions) => TSchema | Promise<TSchema>;
type FollowingTriggerHandler<TType extends QueryType, TSchema = unknown> = (query: FilteredTriggerQuery<TType>, multipleRecords: boolean, beforeResult: TSchema, afterResult: TSchema, options: TriggerOptions) => void | Promise<void>;
declare const TRIGGER_TYPES: readonly ["before", "during", "after", "resolving", "following"];
type TriggerType = (typeof TRIGGER_TYPES)[number];
type TriggerKeys = ({
    [K in QueryType]: `before${Capitalize<K>}`;
} | {
    [K in QueryType]: K;
} | {
    [K in QueryType]: `after${Capitalize<K>}`;
} | {
    [K in QueryType]: `resolving${Capitalize<K>}`;
} | {
    [K in QueryType]: `following${Capitalize<K>}`;
})[QueryType];
type Trigger<TStage extends TriggerType, TType extends QueryType, TSchema extends TStage extends 'before' | 'during' | 'after' ? never : unknown = never> = TStage extends 'before' ? BeforeTriggerHandler<TType> : TStage extends 'during' ? DuringTriggerHandler<TType> : TStage extends 'after' ? AfterTriggerHandler<TType> : TStage extends 'resolving' ? ResolvingTriggerHandler<TType, TSchema> : TStage extends 'following' ? FollowingTriggerHandler<TType, TSchema> : never;
type TriggerList<TSchema = unknown> = {
    [K in TriggerKeys]?: K extends 'before' | `before${string}` ? BeforeTriggerHandler<QueryType> : K extends 'after' | `after${string}` ? AfterTriggerHandler<QueryType> : K extends 'resolving' | `resolving${string}` ? ResolvingTriggerHandler<QueryType, TSchema> : K extends 'following' | `following${string}` ? FollowingTriggerHandler<QueryType, TSchema> : DuringTriggerHandler<QueryType>;
};
type Triggers<TSchema = unknown> = Record<string, TriggerList<TSchema>>;
type BeforeTrigger<TType extends QueryType> = Trigger<'before', TType>;
type DuringTrigger<TType extends QueryType> = Trigger<'during', TType>;
type AfterTrigger<TType extends QueryType> = Trigger<'after', TType>;
type ResolvingTrigger<TType extends QueryType, TSchema = unknown> = Trigger<'resolving', TType, TSchema>;
type FollowingTrigger<TType extends QueryType, TSchema = unknown> = Trigger<'following', TType, TSchema>;
type BeforeGetTrigger = BeforeTrigger<'get'>;
type BeforeSetTrigger = BeforeTrigger<'set'>;
type BeforeAddTrigger = BeforeTrigger<'add'>;
type BeforeRemoveTrigger = BeforeTrigger<'remove'>;
type BeforeCountTrigger = BeforeTrigger<'count'>;
type BeforeCreateTrigger = BeforeTrigger<'create'>;
type BeforeAlterTrigger = BeforeTrigger<'alter'>;
type BeforeDropTrigger = BeforeTrigger<'drop'>;
type GetTrigger = DuringTrigger<'get'>;
type SetTrigger = DuringTrigger<'set'>;
type AddTrigger = DuringTrigger<'add'>;
type RemoveTrigger = DuringTrigger<'remove'>;
type CountTrigger = DuringTrigger<'count'>;
type CreateTrigger = DuringTrigger<'create'>;
type AlterTrigger = DuringTrigger<'alter'>;
type DropTrigger = DuringTrigger<'drop'>;
type AfterGetTrigger = AfterTrigger<'get'>;
type AfterSetTrigger = AfterTrigger<'set'>;
type AfterAddTrigger = AfterTrigger<'add'>;
type AfterRemoveTrigger = AfterTrigger<'remove'>;
type AfterCountTrigger = AfterTrigger<'count'>;
type AfterCreateTrigger = AfterTrigger<'create'>;
type AfterAlterTrigger = AfterTrigger<'alter'>;
type AfterDropTrigger = AfterTrigger<'drop'>;
type ResolvingGetTrigger<TSchema = unknown> = ResolvingTrigger<'get', TSchema>;
type ResolvingSetTrigger<TSchema = unknown> = ResolvingTrigger<'set', TSchema>;
type ResolvingAddTrigger<TSchema = unknown> = ResolvingTrigger<'add', TSchema>;
type ResolvingRemoveTrigger<TSchema = unknown> = ResolvingTrigger<'remove', TSchema>;
type ResolvingCountTrigger<TSchema = unknown> = ResolvingTrigger<'count', TSchema>;
type ResolvingCreateTrigger<TSchema = unknown> = ResolvingTrigger<'create', TSchema>;
type ResolvingAlterTrigger<TSchema = unknown> = ResolvingTrigger<'alter', TSchema>;
type ResolvingDropTrigger<TSchema = unknown> = ResolvingTrigger<'drop', TSchema>;
type FollowingGetTrigger<TSchema = unknown> = FollowingTrigger<'get', TSchema>;
type FollowingSetTrigger<TSchema = unknown> = FollowingTrigger<'set', TSchema>;
type FollowingAddTrigger<TSchema = unknown> = FollowingTrigger<'add', TSchema>;
type FollowingRemoveTrigger<TSchema = unknown> = FollowingTrigger<'remove', TSchema>;
type FollowingCountTrigger<TSchema = unknown> = FollowingTrigger<'count', TSchema>;
type FollowingCreateTrigger<TSchema = unknown> = FollowingTrigger<'create', TSchema>;
type FollowingAlterTrigger<TSchema = unknown> = FollowingTrigger<'alter', TSchema>;
type FollowingDropTrigger<TSchema = unknown> = FollowingTrigger<'drop', TSchema>;
interface TriggerContext {
    triggerType: TriggerType;
    queryType: QueryType;
    queryModel: string;
}

interface QueryHandlerOptions {
    /**
     * Object containing triggers for defined schemas.
     */
    triggers?: Triggers;
    /**
     * Specific query types for which "during" triggers should be required.
     */
    requireTriggers?: 'all' | 'write' | 'read';
    /**
     * Token used to authenticate against RONIN. By default,
     * `process.env.RONIN_TOKEN` will be used.
     */
    token?: string;
    /**
     * Allows for specifying custom options that should be passed to the `fetch`
     * function used to make network requests.
     *
     * Alternatively, an entire `fetch` replacement function may be passed.
     */
    fetch?: Parameters<typeof fetch>[1] | typeof fetch;
    /**
     * Allows for extending the lifetime of the edge worker invocation until the
     * provided promise has been resolved. If the `triggers` option is provided on
     * an edge runtime, this option is required.
     */
    waitUntil?: (promise: Promise<unknown>) => void;
    /**
     * If the query should be run for a specific database within your space, you may
     * provide the desired database name here.
     */
    database?: string;
    /**
     * Sets the `implicit` option received by triggers, allowing for indicating whether the
     * client is being invoked from within triggers.
     *
     * In order to automatically resume the configuration of the client, it is highly
     * recommended to use the client provided in the `options.client` argument for triggers.
     */
    implicit?: boolean;
}
/**
 * Utility type to make all properties of an object optional.
 */
type RecursivePartial<T> = {
    [K in keyof T]?: T[K] extends Array<infer U> ? Array<RecursivePartial<U>> : T[K] extends object ? RecursivePartial<T[K]> : T[K];
};
/**
 * Utility type to convert a tuple of promises into a tuple of their resolved types.
 */
type PromiseTuple<T extends [Promise<any>, ...Array<Promise<any>>] | Array<Promise<any>>> = {
    [P in keyof T]: Awaited<T[P]>;
};
type RegularFormattedResult<T> = number | (T & ResultRecord) | (Array<T & ResultRecord> & {
    moreBefore?: string;
    moreAfter?: string;
}) | null;
type ExpandedFormattedResult<T> = Record<Model['slug'], RegularFormattedResult<T>>;
type FormattedResult<T> = RegularFormattedResult<T> | ExpandedFormattedResult<T>;
type FormattedResults<T> = Array<FormattedResult<T>>;

/**
 * Creates a syntax factory for generating and executing queries.
 *
 * @param options - An optional object of options for the query execution.
 *
 * Alternatively, a function that returns the object may be provided instead, which is
 * useful for cases in which the config must be generated dynamically whenever a query
 * is executed.
 *
 * @returns An object with methods for generating and executing different types
 * of queries.
 *
 * ### Usage
 * ```typescript
 * const { get, set, add, remove, count } = createSyntaxFactory({
 *   token: '...'
 * });
 *
 * await get.accounts();
 *
 * await set.account({
 *   with: {
 *     email: 'mike@gmail.com',
 *   },
 *   to: {
 *     status: 'active',
 *   },
 * });
 *
 * await add.account({ with: { email: 'mike@gmail.com' } });
 *
 * await remove.accounts.with.emailVerified.notBeing(true);
 *
 * await count.accounts();
 *
 * // Execute a batch of operations
 * const batchResult = await batch(() => [
 *   get.accounts(),
 *   get.account.with.email('mike@gmail.com')
 * ]);
 * ```
 */
declare const createSyntaxFactory: (options: QueryHandlerOptions | (() => QueryHandlerOptions)) => {
    get: DeepCallable<GetQuery>;
    set: DeepCallable<SetQuery>;
    add: DeepCallable<AddQuery>;
    remove: DeepCallable<RemoveQuery>;
    count: DeepCallable<CountQuery, number>;
    list: DeepCallable<ListQuery>;
    create: DeepCallable<CreateQuery, Model$1>;
    alter: DeepCallable<AlterQuery, Model$1 | ModelField | ModelIndex | ModelPreset>;
    drop: DeepCallable<DropQuery, Model$1>;
    batch: <T extends [Promise<any>, ...Array<Promise<any>>] | Array<Promise<any>>>(operations: () => T, queryOptions?: Record<string, unknown>) => Promise<PromiseTuple<T>>;
    sql: (strings: TemplateStringsArray, ...values: Array<unknown>) => Promise<any>;
    sqlBatch: <T extends [Promise<any>, ...Array<Promise<any>>] | Array<Promise<any>>>(operations: () => T, queryOptions?: Record<string, unknown>) => Promise<PromiseTuple<T>>;
};
declare const get: DeepCallable<GetQuery>;
declare const set: DeepCallable<SetQuery>;
declare const add: DeepCallable<AddQuery>;
declare const remove: DeepCallable<RemoveQuery>;
declare const count: DeepCallable<CountQuery, number>;
declare const list: DeepCallable<ListQuery>;
declare const create: DeepCallable<CreateQuery, Model$1>;
declare const alter: DeepCallable<AlterQuery, Model$1 | ModelField | ModelIndex | ModelPreset>;
declare const drop: DeepCallable<DropQuery, Model$1>;
declare const batch: <T extends [Promise<any>, ...Array<Promise<any>>] | Array<Promise<any>>>(operations: () => T, queryOptions?: Record<string, unknown>) => Promise<PromiseTuple<T>>;
declare const sql: (strings: TemplateStringsArray, ...values: Array<unknown>) => Promise<any>;
declare const sqlBatch: <T extends [Promise<any>, ...Array<Promise<any>>] | Array<Promise<any>>>(operations: () => T, queryOptions?: Record<string, unknown>) => Promise<PromiseTuple<T>>;

export { remove as $, type AddTrigger as A, type BeforeAddTrigger as B, type CountTrigger as C, type AlterTrigger as D, type AfterAlterTrigger as E, type FormattedResults as F, type GetTrigger as G, type FollowingAlterTrigger as H, type BeforeDropTrigger as I, type ResolvingDropTrigger as J, type DropTrigger as K, type AfterDropTrigger as L, type FollowingDropTrigger as M, type BeforeTriggerHandler as N, type DuringTriggerHandler as O, type FollowingTriggerHandler as P, type QueryHandlerOptions as Q, type ResolvingAddTrigger as R, type SetTrigger as S, type AfterTriggerHandler as T, type ResolvingTriggerHandler as U, type TriggerContext as V, type PromiseTuple as W, createSyntaxFactory as X, get as Y, set as Z, add as _, type AfterAddTrigger as a, count as a0, list as a1, create as a2, alter as a3, drop as a4, batch as a5, sql as a6, sqlBatch as a7, type FollowingAddTrigger as b, type BeforeGetTrigger as c, type ResolvingGetTrigger as d, type AfterGetTrigger as e, type FollowingGetTrigger as f, type BeforeSetTrigger as g, type ResolvingSetTrigger as h, type AfterSetTrigger as i, type FollowingSetTrigger as j, type BeforeRemoveTrigger as k, type ResolvingRemoveTrigger as l, type RemoveTrigger as m, type AfterRemoveTrigger as n, type FollowingRemoveTrigger as o, type BeforeCountTrigger as p, type ResolvingCountTrigger as q, type AfterCountTrigger as r, type FollowingCountTrigger as s, type BeforeCreateTrigger as t, type ResolvingCreateTrigger as u, type CreateTrigger as v, type AfterCreateTrigger as w, type FollowingCreateTrigger as x, type BeforeAlterTrigger as y, type ResolvingAlterTrigger as z };