shiro-orm/dist/utils-BsS_PV7b.d.ts

Access your RONIN database via TypeScript.

import { AsyncLocalStorage } from 'node:async_hooks';
import { QueryType, CombinedInstructions, Query, ResultRecord, Model } from 'shiro-compiler';

interface TriggerOptions {
    /** The model for which the query is being executed. */
    model?: string;
    /** The database for which the query is being executed. */
    database?: string;
    /** Whether the query was generated implicitly by an trigger. */
    implicit?: boolean;
}
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;
    /**
     * 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;
    /**
     * Allows for preventing recursions when running queries from triggers
     * provided with the `triggers` option. If the `triggers` option is provided, this
     * option is required.
     */
    asyncContext?: AsyncLocalStorage<any>;
    /**
     * If the query should be run for a specific database within your space, you may
     * provide the desired database name here.
     */
    database?: string;
}
/**
 * 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>>;

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