@primate/core 0.6.3 → 0.7.1

package/lib/private/{orm/store.d.ts → store/Store.d.ts}

@@ -1,13 +1,17 @@
+import type DataDict from "#db/DataDict";
 import type DB from "#db/DB";
 import type PK from "#db/PK";
 import type Types from "#db/Types";
-import type ExtractSchema from "#orm/ExtractSchema";
-import type PrimaryKey from "#orm/PrimaryKey";
-import type { ManyRelation, OneRelation, Relation } from "#orm/relation";
-import type StoreInput from "#orm/StoreInput";
-import type { Dict, EmptyObject, Serializable } from "@rcompat/type";
+import type ExtractRelations from "#store/ExtractRelation";
+import type ExtractSchema from "#store/ExtractSchema";
+import type Init from "#store/Init";
+import type PrimaryKey from "#store/PrimaryKey";
+import type { ManyRelation, OneRelation, Relation } from "#store/relation";
+import type StoreInput from "#store/StoreInput";
+import type { Dict, Serializable } from "@rcompat/type";
 import type { DefaultType, InferStore, Storable } from "pema";
 import StoreType from "pema/StoreType";
+declare const brand: unique symbol;
 type X<T> = {
     [K in keyof T]: T[K];
 } & {};
@@ -17,6 +21,7 @@ type OrNull<T> = {
 type StringOperators = {
     $like?: string;
     $ilike?: string;
+    $in?: string[];
 };
 type NumberOperators = {
     $gt?: number;
@@ -24,6 +29,7 @@ type NumberOperators = {
     $lt?: number;
     $lte?: number;
     $ne?: number;
+    $in?: number[];
 };
 type BigIntOperators = {
     $gt?: bigint;
@@ -31,11 +37,13 @@ type BigIntOperators = {
     $lt?: bigint;
     $lte?: bigint;
     $ne?: bigint;
+    $in?: bigint[];
 };
 type DateOperators = {
     $before?: Date;
     $after?: Date;
     $ne?: Date;
+    $in?: Date[];
 };
 type QueryOperators<T> = T extends string ? (T | StringOperators | null) : T extends number ? (T | NumberOperators | null) : T extends bigint ? (T | BigIntOperators | null) : T extends Date ? (T | DateOperators | null) : (T | null);
 type InferRecord<T extends StoreInput> = InferStore<ExtractSchema<T>>;
@@ -55,37 +63,30 @@ type Insertable<T extends StoreInput> = Omit<InferRecord<T>, PrimaryKeyField<T>
 type PrimaryKeyField<T extends StoreInput> = {
     [K in keyof T]: T[K] extends PrimaryKey<any> ? K : never;
 }[keyof T] & keyof InferRecord<T>;
+type SchemaOf<S> = S extends Store<infer T, any> ? Schema<T> : never;
+type StoreT<S> = S extends Store<infer T, any> ? T : never;
+type RelationTable<R> = R extends OneRelation<infer N, string> ? N : R extends ManyRelation<infer N, string> ? N : never;
+type RelationStore<N extends string> = Store<any, N>;
+type WithQuery<N extends string, S extends RelationStore<N> = RelationStore<N>> = {
+    store: S;
+    where?: Where<StoreT<S>> & DataDict;
+    select?: readonly (keyof Schema<StoreT<S>> & string)[];
+    sort?: Sort<Schema<StoreT<S>>> & ReadSort;
+    limit?: number;
+};
+type WithInput<R extends Dict<Relation>> = {
+    [K in keyof R]?: RelationStore<RelationTable<R[K]>> | WithQuery<RelationTable<R[K]>, RelationStore<RelationTable<R[K]>>>;
+};
+type RelationResult<Rel, W> = Rel extends OneRelation<string, string> ? W extends WithQuery<string, infer S> ? W["select"] extends readonly (keyof SchemaOf<S> & string)[] ? Pick<SchemaOf<S>, W["select"][number]> | null : SchemaOf<S> | null : SchemaOf<W> | null : Rel extends ManyRelation<string, string> ? W extends WithQuery<string, infer S> ? W["select"] extends readonly (keyof SchemaOf<S> & string)[] ? Pick<SchemaOf<S>, W["select"][number]>[] : SchemaOf<S>[] : SchemaOf<W>[] : never;
+type WithRelations<Base, R extends Dict<Relation>, W extends WithInput<R> | undefined> = W extends object ? X<Base & {
+    [K in keyof W & keyof R]: RelationResult<R[K], W[K]>;
+}> : Base;
 declare const NUMBER_KEYS: readonly ["u8", "u16", "u32", "i8", "i16", "i32", "f32", "f64"];
 declare const BIGINT_KEYS: readonly ["u64", "u128", "i64", "i128"];
 type NumberKey = typeof NUMBER_KEYS[number];
 type BigIntKey = typeof BIGINT_KEYS[number];
 type PKV<T extends StoreInput> = T[PrimaryKeyField<T>] extends PrimaryKey<infer P> ? P extends Storable<infer D> ? D extends "uuid" | "uuid_v4" | "uuid_v7" ? string : D extends NumberKey ? number : D extends BigIntKey ? bigint : string | number | bigint : string | number | bigint : string | number | bigint;
-type WithQuery<T extends StoreInput> = true | {
-    where?: Where<T>;
-    select?: Select<Schema<T>>;
-    sort?: Sort<Schema<T>>;
-    limit?: number;
-};
-type With<R extends Dict<Relation>> = {
-    [K in keyof R]?: R[K] extends OneRelation<infer S, string> ? WithQuery<S> : R[K] extends ManyRelation<infer S, string> ? WithQuery<S> : never;
-};
-type RelationResult<Rel, Q> = Rel extends OneRelation<infer S, string> ? Q extends {
-    select: infer Sel;
-} ? Sel extends Select<Schema<S>> ? Projected<Schema<S>, Sel> | null : Schema<S> | null : Schema<S> | null : Rel extends ManyRelation<infer S, string> ? Q extends {
-    select: infer Sel;
-} ? Sel extends Select<Schema<S>> ? Projected<Schema<S>, Sel>[] : Schema<S>[] : Schema<S>[] : never;
-type WithRelations<Base, Relations extends Dict<Relation>, W extends With<Relations> | undefined> = W extends object ? X<Base & {
-    [K in keyof W & keyof Relations]: RelationResult<Relations[K], W[K]>;
-}> : Base;
-type Init<S extends StoreInput, R extends Dict<Relation>> = {
-    name: string;
-    db: DB;
-    id?: symbol;
-    schema: S;
-    relations?: R;
-    migrate?: boolean;
-    extend?: Dict;
-};
+type ReadSort = Dict<"asc" | "desc">;
 /**
  * Database-backed store.
  *
@@ -93,22 +94,21 @@ type Init<S extends StoreInput, R extends Dict<Relation>> = {
  * document database table/collection. It pairs a Pema schema with a uniform
  * CRUD/query API.
  */
-export declare class Store<T extends StoreInput, R extends Dict<Relation> = EmptyObject> implements Serializable {
+export default class Store<T extends StoreInput, N extends string = string> implements Serializable {
     #private;
+    [brand]: boolean;
     readonly Schema: Schema<T>;
-    constructor(init: Init<T, R>);
-    get table(): {
-        create: () => import("@rcompat/type").MaybePromise<void>;
-        delete: () => import("@rcompat/type").MaybePromise<void>;
-    };
+    static is(x: unknown): x is Store<any, any>;
+    constructor(init: Init<T, N>);
+    create(): Promise<void>;
+    drop(): Promise<void>;
     get infer(): InferRecord<T>;
-    get schema(): Dict<Storable<keyof import("pema").DataType, unknown>>;
-    get type(): StoreType<ExtractSchema<T>>;
+    get schema(): StoreType<ExtractSchema<T>>;
     get migrate(): boolean;
     get id(): symbol;
-    get name(): string;
+    get table(): N;
     get pk(): PK;
-    get db(): DB;
+    get db(): DB<unknown>;
     get types(): Types;
     /**
      * Count records
@@ -128,18 +128,18 @@ export declare class Store<T extends StoreInput, R extends Dict<Relation> = Empt
      * - With `with`: augments the record with relations.
      */
     get(pkv: PKV<T>): Promise<Schema<T>>;
-    get<const S extends Select<Schema<T>> | undefined = undefined, const W extends With<R> | undefined = undefined>(pkv: PKV<T>, options: {
+    get<const S extends Select<Schema<T>> | undefined = undefined, const W extends WithInput<ExtractRelations<T>> | undefined = undefined>(pkv: PKV<T>, options: {
         select?: S;
         with?: W;
-    }): Promise<WithRelations<Projected<Schema<T>, S>, R, W>>;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, ExtractRelations<T>, W>>;
     /**
      * Try to get a record by primary key.
      */
     try(pkv: PKV<T>): Promise<Schema<T> | undefined>;
-    try<const S extends Select<Schema<T>> | undefined = undefined, const W extends With<R> | undefined = undefined>(pkv: PKV<T>, options: {
+    try<const S extends Select<Schema<T>> | undefined = undefined, const W extends WithInput<ExtractRelations<T>> | undefined = undefined>(pkv: PKV<T>, options: {
         select?: S;
         with?: W;
-    }): Promise<WithRelations<Projected<Schema<T>, S>, R, W> | undefined>;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, ExtractRelations<T>, W> | undefined>;
     /**
      * Insert a single record.
      */
@@ -171,19 +171,19 @@ export declare class Store<T extends StoreInput, R extends Dict<Relation> = Empt
      * Find matching records
      *
      */
-    find<const S extends Select<Schema<T>> | undefined = undefined, const W extends With<R> | undefined = undefined>(options?: {
+    find<const S extends Select<Schema<T>> | undefined = undefined, const W extends WithInput<ExtractRelations<T>> | undefined = undefined>(options?: {
         where?: Where<T>;
         select?: S;
         sort?: Sort<Schema<T>>;
         limit?: number;
+        offset?: number;
         with?: W;
-    }): Promise<WithRelations<Projected<Schema<T>, S>, R, W>[]>;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, ExtractRelations<T>, W>[]>;
     toJSON(): {
         type: "object";
         properties: Dict<import("pema").Serialized>;
     };
     extend<A extends Dict>(extensor: (This: this) => A): this & A;
 }
-declare function store<T extends StoreInput, R extends Dict<Relation> = EmptyObject>(init: Init<T, R>): Store<T, R>;
-export default store;
-//# sourceMappingURL=store.d.ts.map
+export {};
+//# sourceMappingURL=Store.d.ts.map