@farming-labs/orm 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,254 @@
+type ScalarKind = "id" | "string" | "boolean" | "datetime";
+type FieldReference = `${string}.${string}`;
+type FieldConfig<Kind extends ScalarKind = ScalarKind, Nullable extends boolean = boolean> = {
+    kind: Kind;
+    nullable: Nullable;
+    unique: boolean;
+    defaultValue?: unknown;
+    generated?: "id" | "now";
+    mappedName?: string;
+    references?: FieldReference;
+    description?: string;
+};
+type AnyFieldBuilder = FieldBuilder<ScalarKind, boolean>;
+declare class FieldBuilder<Kind extends ScalarKind, Nullable extends boolean = false> {
+    readonly config: FieldConfig<Kind, Nullable>;
+    readonly _tag = "field";
+    constructor(config: FieldConfig<Kind, Nullable>);
+    unique(): FieldBuilder<Kind, Nullable>;
+    nullable(): FieldBuilder<Kind, true>;
+    default(value: unknown): FieldBuilder<Kind, Nullable>;
+    defaultNow(): FieldBuilder<Kind, Nullable>;
+    references(reference: FieldReference): FieldBuilder<Kind, Nullable>;
+    map(name: string): FieldBuilder<Kind, Nullable>;
+    describe(description: string): FieldBuilder<Kind, Nullable>;
+}
+type ScalarValue<Kind extends ScalarKind> = Kind extends "id" ? string : Kind extends "string" ? string : Kind extends "boolean" ? boolean : Date;
+type FieldOutput<TField> = TField extends FieldBuilder<infer Kind, infer Nullable> ? Nullable extends true ? ScalarValue<Kind> | null : ScalarValue<Kind> : never;
+declare function id(): FieldBuilder<"id", false>;
+declare function string(): FieldBuilder<"string", false>;
+declare function boolean(): FieldBuilder<"boolean", false>;
+declare function datetime(): FieldBuilder<"datetime", false>;
+
+type RelationKind = "belongsTo" | "hasOne" | "hasMany" | "manyToMany";
+type RelationDefinition<Target extends string = string, Kind extends RelationKind = RelationKind> = Kind extends "manyToMany" ? {
+    kind: Kind;
+    target: Target;
+    through: string;
+    from: string;
+    to: string;
+} : {
+    kind: Kind;
+    target: Target;
+    foreignKey: string;
+};
+type AnyRelation = RelationDefinition<string, RelationKind>;
+declare function belongsTo<Target extends string>(target: Target, config: {
+    foreignKey: string;
+}): {
+    kind: "belongsTo";
+    target: Target;
+    foreignKey: string;
+};
+declare function hasOne<Target extends string>(target: Target, config: {
+    foreignKey: string;
+}): {
+    kind: "hasOne";
+    target: Target;
+    foreignKey: string;
+};
+declare function hasMany<Target extends string>(target: Target, config: {
+    foreignKey: string;
+}): {
+    kind: "hasMany";
+    target: Target;
+    foreignKey: string;
+};
+declare function manyToMany<Target extends string>(target: Target, config: {
+    through: string;
+    from: string;
+    to: string;
+}): {
+    kind: "manyToMany";
+    target: Target;
+    through: string;
+    from: string;
+    to: string;
+};
+
+type FieldMap = Record<string, AnyFieldBuilder>;
+type RelationMap = Record<string, AnyRelation>;
+type ModelDefinition<Fields extends FieldMap = FieldMap, Relations extends RelationMap = RelationMap> = {
+    readonly _tag: "model";
+    readonly table: string;
+    readonly fields: Fields;
+    readonly relations: Relations;
+    readonly description?: string;
+};
+type AnyModelDefinition = ModelDefinition<FieldMap, RelationMap>;
+type SchemaDefinition<Models extends Record<string, AnyModelDefinition> = Record<string, AnyModelDefinition>> = {
+    readonly _tag: "schema";
+    readonly models: Models;
+};
+declare function model<Fields extends FieldMap, Relations extends RelationMap = {}>(config: {
+    table: string;
+    fields: Fields;
+    relations?: Relations;
+    description?: string;
+}): ModelDefinition<Fields, Relations>;
+declare function defineSchema<Models extends Record<string, AnyModelDefinition>>(models: Models): SchemaDefinition<Models>;
+type SchemaModels<TSchema> = TSchema extends SchemaDefinition<infer Models> ? Models : never;
+type ModelName<TSchema> = keyof SchemaModels<TSchema> & string;
+type ModelForName<TSchema, TName extends ModelName<TSchema>> = SchemaModels<TSchema>[TName];
+type ModelFields<TSchema, TName extends ModelName<TSchema>> = ModelForName<TSchema, TName>["fields"];
+type ModelRelations<TSchema, TName extends ModelName<TSchema>> = ModelForName<TSchema, TName>["relations"];
+type ScalarRecord<TSchema, TName extends ModelName<TSchema>> = {
+    [K in keyof ModelFields<TSchema, TName> & string]: FieldOutput<ModelFields<TSchema, TName>[K]>;
+};
+type RelationName<TSchema, TName extends ModelName<TSchema>> = keyof ModelRelations<TSchema, TName> & string;
+type RelationForName<TSchema, TName extends ModelName<TSchema>, TRelationName extends RelationName<TSchema, TName>> = ModelRelations<TSchema, TName>[TRelationName];
+type RelationTarget<TSchema, TName extends ModelName<TSchema>, TRelationName extends RelationName<TSchema, TName>> = RelationForName<TSchema, TName, TRelationName> extends RelationDefinition<infer Target, any> ? Extract<Target, ModelName<TSchema>> : never;
+
+type Direction = "asc" | "desc";
+type Primitive = string | number | boolean | Date | null;
+type Comparable = string | number | Date;
+type ValueFilter<T> = T extends string ? T | {
+    eq?: T;
+    contains?: string;
+    in?: T[];
+    not?: T;
+} : T extends Comparable ? T | {
+    eq?: T;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    in?: T[];
+    not?: T;
+} : T | {
+    eq?: T;
+    in?: T[];
+    not?: T;
+};
+type Where<TRecord extends Record<string, Primitive>> = {
+    [K in keyof TRecord]?: ValueFilter<TRecord[K]>;
+} & {
+    AND?: Array<Where<TRecord>>;
+    OR?: Array<Where<TRecord>>;
+    NOT?: Where<TRecord>;
+};
+type RelationQuery<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where?: Where<ScalarRecord<TSchema, TModelName>>;
+    select?: SelectShape<TSchema, TModelName>;
+    orderBy?: Partial<Record<keyof ScalarRecord<TSchema, TModelName> & string, Direction>>;
+    take?: number;
+    skip?: number;
+};
+type RelationSelectionValue<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TRelationName extends RelationName<TSchema, TModelName>> = true | RelationQuery<TSchema, RelationTarget<TSchema, TModelName, TRelationName>>;
+type SelectShape<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    [K in (keyof ScalarRecord<TSchema, TModelName> & string) | RelationName<TSchema, TModelName>]?: K extends RelationName<TSchema, TModelName> ? true | RelationQuery<TSchema, any> : true;
+};
+type IsManyRelation<TRelation> = TRelation extends {
+    kind: "hasMany" | "manyToMany";
+} ? true : false;
+type DefaultSelectedRecord<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = ScalarRecord<TSchema, TModelName>;
+type SelectedScalars<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName>> = {
+    [K in keyof TSelect & keyof ScalarRecord<TSchema, TModelName> as TSelect[K] extends true ? K : never]: ScalarRecord<TSchema, TModelName>[K];
+};
+type RelationResult<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TRelationName extends RelationName<TSchema, TModelName>, TValue extends RelationSelectionValue<TSchema, TModelName, TRelationName>> = TValue extends true ? IsManyRelation<RelationForName<TSchema, TModelName, TRelationName>> extends true ? Array<DefaultSelectedRecord<TSchema, RelationTarget<TSchema, TModelName, TRelationName>>> : DefaultSelectedRecord<TSchema, RelationTarget<TSchema, TModelName, TRelationName>> | null : TValue extends RelationQuery<TSchema, infer Target> ? Target extends ModelName<TSchema> ? IsManyRelation<RelationForName<TSchema, TModelName, TRelationName>> extends true ? Array<SelectedRecord<TSchema, Target, TValue["select"] extends SelectShape<TSchema, Target> ? TValue["select"] : undefined>> : SelectedRecord<TSchema, Target, TValue["select"] extends SelectShape<TSchema, Target> ? TValue["select"] : undefined> | null : never : never;
+type SelectedRelations<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName>> = {
+    [K in keyof TSelect & RelationName<TSchema, TModelName>]: RelationResult<TSchema, TModelName, K, Extract<TSelect[K], RelationSelectionValue<TSchema, TModelName, K>>>;
+};
+type SelectedRecord<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined> = TSelect extends SelectShape<TSchema, TModelName> ? SelectedScalars<TSchema, TModelName, TSelect> & SelectedRelations<TSchema, TModelName, TSelect> : DefaultSelectedRecord<TSchema, TModelName>;
+type FindManyArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    where?: Where<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+    orderBy?: Partial<Record<keyof ScalarRecord<TSchema, TModelName> & string, Direction>>;
+    take?: number;
+    skip?: number;
+};
+type FindFirstArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = FindManyArgs<TSchema, TModelName, TSelect>;
+type CreateArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    data: Partial<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+};
+type UpdateArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+    data: Partial<ScalarRecord<TSchema, TModelName>>;
+    select?: TSelect;
+};
+type DeleteArgs<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    where: Where<ScalarRecord<TSchema, TModelName>>;
+};
+interface OrmDriver<TSchema extends SchemaDefinition<any>> {
+    findMany<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
+    findFirst<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: FindFirstArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    create<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: CreateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
+    update<TModelName extends ModelName<TSchema>, TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(schema: TSchema, model: TModelName, args: UpdateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    delete<TModelName extends ModelName<TSchema>>(schema: TSchema, model: TModelName, args: DeleteArgs<TSchema, TModelName>): Promise<number>;
+    transaction<TResult>(schema: TSchema, run: (driver: OrmDriver<TSchema>) => Promise<TResult>): Promise<TResult>;
+}
+type ModelClient<TSchema extends SchemaDefinition<any>, TModelName extends ModelName<TSchema>> = {
+    findMany<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindManyArgs<TSchema, TModelName, TSelect>): Promise<Array<SelectedRecord<TSchema, TModelName, TSelect>>>;
+    findFirst<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args?: FindFirstArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    create<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: CreateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect>>;
+    update<TSelect extends SelectShape<TSchema, TModelName> | undefined = undefined>(args: UpdateArgs<TSchema, TModelName, TSelect>): Promise<SelectedRecord<TSchema, TModelName, TSelect> | null>;
+    delete(args: DeleteArgs<TSchema, TModelName>): Promise<number>;
+};
+type OrmClient<TSchema extends SchemaDefinition<any>> = {
+    [K in ModelName<TSchema>]: ModelClient<TSchema, K>;
+} & {
+    transaction<TResult>(run: (tx: OrmClient<TSchema>) => Promise<TResult>): Promise<TResult>;
+};
+declare function createOrm<TSchema extends SchemaDefinition<any>>(options: {
+    schema: TSchema;
+    driver: OrmDriver<TSchema>;
+}): OrmClient<TSchema>;
+
+type PrismaGenerationOptions = {
+    provider?: "postgresql" | "mysql" | "sqlite";
+    datasourceName?: string;
+    generatorName?: string;
+};
+type DrizzleGenerationOptions = {
+    dialect: "pg" | "mysql" | "sqlite";
+};
+type SqlGenerationOptions = {
+    dialect: "postgres" | "mysql" | "sqlite";
+};
+declare function renderPrismaSchema(schema: SchemaDefinition<any>, options?: PrismaGenerationOptions): string;
+declare function renderDrizzleSchema(schema: SchemaDefinition<any>, options: DrizzleGenerationOptions): string;
+declare function renderSafeSql(schema: SchemaDefinition<any>, options: SqlGenerationOptions): string;
+declare function replaceGeneratedBlock(input: {
+    current: string;
+    label: string;
+    content: string;
+}): string;
+
+type ManifestField = {
+    name: string;
+    column: string;
+    kind: ScalarKind;
+    nullable: boolean;
+    unique: boolean;
+    generated?: "id" | "now";
+    defaultValue?: unknown;
+    references?: string;
+    description?: string;
+};
+type ManifestModel = {
+    name: string;
+    table: string;
+    description?: string;
+    fields: Record<string, ManifestField>;
+    relations: Record<string, AnyRelation>;
+};
+type SchemaManifest = {
+    models: Record<string, ManifestModel>;
+};
+declare function createManifest<TSchema extends SchemaDefinition<Record<string, AnyModelDefinition>>>(schema: TSchema): SchemaManifest;
+
+type MemoryStore<TSchema extends SchemaDefinition<any>> = Partial<Record<ModelName<TSchema>, Array<Record<string, unknown>>>>;
+declare function createMemoryDriver<TSchema extends SchemaDefinition<any>>(seed?: MemoryStore<TSchema>): OrmDriver<TSchema>;
+
+export { type AnyFieldBuilder, type AnyModelDefinition, type AnyRelation, type CreateArgs, type DeleteArgs, type DrizzleGenerationOptions, FieldBuilder, type FieldConfig, type FieldMap, type FieldOutput, type FieldReference, type FindFirstArgs, type FindManyArgs, type ManifestField, type ManifestModel, type ModelClient, type ModelDefinition, type ModelFields, type ModelForName, type ModelName, type ModelRelations, type OrmClient, type OrmDriver, type PrismaGenerationOptions, type RelationDefinition, type RelationForName, type RelationKind, type RelationMap, type RelationName, type RelationTarget, type ScalarKind, type ScalarRecord, type ScalarValue, type SchemaDefinition, type SchemaManifest, type SchemaModels, type SelectShape, type SelectedRecord, type SqlGenerationOptions, type UpdateArgs, type Where, belongsTo, boolean, createManifest, createMemoryDriver, createOrm, datetime, defineSchema, hasMany, hasOne, id, manyToMany, model, renderDrizzleSchema, renderPrismaSchema, renderSafeSql, replaceGeneratedBlock, string };