bknd/dist/types/data/prototype/index.d.ts

Lightweight Firebase/Supabase alternative built to run anywhere — incl. Next.js, React Router, Astro, Cloudflare, Bun, Node, AWS Lambda & more.

import { EntityManager } from "../../data/entities/EntityManager";
import type { Generated } from "kysely";
import { MediaField, type MediaFieldConfig, type MediaItem } from "../../media/MediaField";
import type { ModuleConfigs } from "../../modules";
import { BooleanField, type BooleanFieldConfig, type Connection, DateField, type DateFieldConfig, Entity, type EntityConfig, EntityIndex, type EntityRelation, EnumField, type EnumFieldConfig, type Field, JsonField, type JsonFieldConfig, JsonSchemaField, type JsonSchemaFieldConfig, ManyToManyRelation, type ManyToManyRelationConfig, ManyToOneRelation, type ManyToOneRelationConfig, NumberField, type NumberFieldConfig, OneToOneRelation, type OneToOneRelationConfig, PolymorphicRelation, type PolymorphicRelationConfig, type TEntityType, TextField, type TextFieldConfig } from "../index";
type Options<Config = any> = {
    entity: {
        name: string;
        fields: Record<string, Field<any, any, any>>;
    };
    field_name: string;
    config: Config;
    is_required: boolean;
    another?: string;
};
declare const FieldMap: {
    readonly text: (o: Options) => TextField<false>;
    readonly number: (o: Options) => NumberField<false>;
    readonly date: (o: Options) => DateField<false>;
    readonly datetime: (o: Options) => DateField<false>;
    readonly boolean: (o: Options) => BooleanField<false>;
    readonly enumm: (o: Options) => EnumField<false, string>;
    readonly json: (o: Options) => JsonField<false, object>;
    readonly jsonSchema: (o: Options) => JsonSchemaField<false, object>;
    readonly media: (o: Options) => MediaField<false, MediaItem[]>;
    readonly medium: (o: Options) => MediaField<false, MediaItem[]>;
};
type TFieldType = keyof typeof FieldMap;
export declare function text(config?: Omit<TextFieldConfig, "required">): TextField<false> & {
    required: () => TextField<true>;
};
export declare function number(config?: Omit<NumberFieldConfig, "required">): NumberField<false> & {
    required: () => NumberField<true>;
};
export declare function date(config?: Omit<DateFieldConfig, "required" | "type">): DateField<false> & {
    required: () => DateField<true>;
};
export declare function datetime(config?: Omit<DateFieldConfig, "required" | "type">): DateField<false> & {
    required: () => DateField<true>;
};
export declare function week(config?: Omit<DateFieldConfig, "required" | "type">): DateField<false> & {
    required: () => DateField<true>;
};
export declare function boolean(config?: Omit<BooleanFieldConfig, "required">): BooleanField<false> & {
    required: () => BooleanField<true>;
};
export declare function enumm<TypeOverride = string>(config?: Omit<EnumFieldConfig, "required" | "options"> & {
    enum: string[] | {
        label: string;
        value: string;
    }[];
}): EnumField<false, TypeOverride> & {
    required: () => EnumField<true, TypeOverride>;
};
export declare function json<TypeOverride = object>(config?: Omit<JsonFieldConfig, "required">): JsonField<false, TypeOverride> & {
    required: () => JsonField<true, TypeOverride>;
};
export declare function jsonSchema<TypeOverride = object>(config?: Omit<JsonSchemaFieldConfig, "required">): JsonField<false, TypeOverride> & {
    required: () => JsonSchemaField<true, TypeOverride>;
};
export declare function media(config?: Omit<MediaFieldConfig, "entity">): MediaField<false>;
export declare function medium(config?: Omit<MediaFieldConfig, "required" | "entity" | "max_items">): MediaField<false, MediaItem>;
export declare function make<Actual extends Field<any, any>>(name: string, field: Actual): Actual;
export declare class FieldPrototype {
    type: TFieldType;
    config: any;
    is_required: boolean;
    constructor(type: TFieldType, config: any, is_required: boolean);
    required(): this;
    getField(o: Options): Field;
    make(field_name: string): Field;
}
export declare function entity<EntityName extends string, Fields extends Record<string, Field<any, any, any>>>(name: EntityName, fields: Fields, config?: EntityConfig, type?: TEntityType): Entity<EntityName, Fields>;
export declare function relation<Local extends Entity>(local: Local): {
    manyToOne: <Foreign extends Entity>(foreign: Foreign, config?: ManyToOneRelationConfig) => ManyToOneRelation;
    oneToOne: <Foreign extends Entity>(foreign: Foreign, config?: OneToOneRelationConfig) => OneToOneRelation;
    manyToMany: <Foreign extends Entity>(foreign: Foreign, config?: ManyToManyRelationConfig, additionalFields?: Record<string, Field<any, any, any>>) => ManyToManyRelation;
    polyToOne: <Foreign extends Entity>(foreign: Foreign, config?: Omit<PolymorphicRelationConfig, "targetCardinality">) => PolymorphicRelation;
    polyToMany: <Foreign extends Entity>(foreign: Foreign, config?: PolymorphicRelationConfig) => PolymorphicRelation;
};
export declare function index<E extends Entity>(entity: E): {
    on: (fields: (keyof InsertSchema<E>)[], unique?: boolean) => EntityIndex;
};
declare class EntityManagerPrototype<Entities extends Record<string, Entity>> extends EntityManager<Schema<Entities>> {
    __entities: Entities;
    constructor(__entities: Entities, relations?: EntityRelation[], indices?: EntityIndex[]);
    withConnection(connection: Connection): EntityManager<Schema<Entities>>;
}
type Chained<R extends Record<string, (...args: any[]) => any>> = {
    [K in keyof R]: R[K] extends (...args: any[]) => any ? (...args: Parameters<R[K]>) => Chained<R> : never;
};
type ChainedFn<Fn extends (...args: any[]) => Record<string, (...args: any[]) => any>, Return extends ReturnType<Fn> = ReturnType<Fn>> = (e: Entity) => {
    [K in keyof Return]: (...args: Parameters<Return[K]>) => Chained<Return>;
};
export declare function em<Entities extends Record<string, Entity>>(entities: Entities, schema?: (fns: {
    relation: ChainedFn<typeof relation>;
    index: ChainedFn<typeof index>;
}, entities: Entities) => void): {
    DB: Schemas<Entities>;
    entities: Entities;
    relations: EntityRelation<import("@sinclair/typebox").TObject<{
        mappedBy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
        inversedBy: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
        required: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
    }>>[];
    indices: EntityIndex[];
    proto: EntityManagerPrototype<Entities>;
    toJSON: () => Pick<ModuleConfigs["data"], "entities" | "relations" | "indices">;
};
export type InferEntityFields<T> = T extends Entity<infer _N, infer Fields> ? {
    [K in keyof Fields]: Fields[K] extends {
        _type: infer Type;
        _required: infer Required;
    } ? Required extends true ? Type : Type | undefined : never;
} : never;
export type InferFields<Fields> = Fields extends Record<string, Field<any, any, any>> ? {
    [K in keyof Fields]: Fields[K] extends {
        _type: infer Type;
        _required: infer Required;
    } ? Required extends true ? Type : Type | undefined : never;
} : never;
export type Simplify<T> = {
    [KeyType in keyof T]: T[KeyType];
} & {};
type Merge<T> = {
    [K in keyof T]: T[K];
};
type OptionalUndefined<T, Props extends keyof T = keyof T, OptionsProps extends keyof T = Props extends keyof T ? undefined extends T[Props] ? Props : never : never> = Merge<{
    [K in OptionsProps]?: T[K];
} & {
    [K in Exclude<keyof T, OptionsProps>]: T[K];
}>;
export type InferField<Field> = Field extends {
    _type: infer Type;
    _required: infer Required;
} ? Required extends true ? Type : Type | undefined : never;
export type Schemas<T extends Record<string, Entity>> = {
    [K in keyof T]: Schema<T[K]>;
};
export type InsertSchema<T> = Simplify<OptionalUndefined<InferEntityFields<T>>>;
export type Schema<T> = Simplify<{
    id: Generated<number>;
} & InsertSchema<T>>;
export type FieldSchema<T> = Simplify<OptionalUndefined<InferFields<T>>>;
export {};