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, DateField, type DateFieldConfig, EntityIndex, EnumField, type EnumFieldConfig, type Field, JsonField, type JsonFieldConfig, JsonSchemaField, type JsonSchemaFieldConfig, NumberField, type NumberFieldConfig, TextField, type TextFieldConfig } from "../../data/fields";
import { Entity, type EntityConfig, type TEntityType } from "../../data/entities";
import type { Connection } from "../../data/connection";
import { type EntityRelation, ManyToManyRelation, type ManyToManyRelationConfig, ManyToOneRelation, type ManyToOneRelationConfig, OneToOneRelation, type OneToOneRelationConfig, PolymorphicRelation, type PolymorphicRelationConfig } from "../../data/relations";
import type { MediaFields } from "../../media/AppMedia";
import type { UsersFields } from "../../auth/AppAuth";
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 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 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 function entity<EntityName extends string, Fields extends Record<string, Field<any, any, any>>>(name: EntityName, fields: Fields, config?: EntityConfig, type?: TEntityType): Entity<EntityName, Fields>;
type SystemEntities = {
    users: UsersFields;
    media: MediaFields;
};
export declare function systemEntity<E extends keyof SystemEntities, Fields extends Record<string, Field<any, any, any>>>(name: E, fields: Fields, config?: EntityConfig): Entity<E, SystemEntities[E] & 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<Schemas<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("jsonv-ts").ObjectSchema<{
        readonly mappedBy: {
            default?: any;
            maxLength?: number | undefined;
            minLength?: number | undefined;
            pattern?: (string | RegExp) | undefined;
            format?: string | undefined;
            enum?: (readonly any[] | any[]) | undefined;
            const?: any;
        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
        readonly inversedBy: {
            default?: any;
            maxLength?: number | undefined;
            minLength?: number | undefined;
            pattern?: (string | RegExp) | undefined;
            format?: string | undefined;
            enum?: (readonly any[] | any[]) | undefined;
            const?: any;
        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, string | undefined, string | undefined>;
        readonly required: {
            default?: any;
            enum?: (readonly any[] | any[]) | undefined;
            const?: any;
        } & import("jsonv-ts").Schema<import("jsonv-ts").ISchemaOptions, boolean | undefined, boolean | undefined>;
    }, import("jsonv-ts").Merge<import("jsonv-ts").IObjectOptions & {
        additionalProperties: false;
    }>>>[];
    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 {};