@primate/core 0.4.6 → 0.6.0

package/lib/private/orm/StoreInput.d.ts

@@ -0,0 +1,10 @@
+import type ForeignKey from "#orm/ForeignKey";
+import type { AllowedFKType } from "#orm/ForeignKey";
+import type PrimaryKey from "#orm/PrimaryKey";
+import type { AllowedPKType } from "#orm/PrimaryKey";
+import type { Dict } from "@rcompat/type";
+import type { DataKey, Storable } from "pema";
+type StoreField = Storable<DataKey> | PrimaryKey<AllowedPKType> | ForeignKey<AllowedFKType>;
+type StoreInput = Dict<StoreField>;
+export type { StoreInput as default };
+//# sourceMappingURL=StoreInput.d.ts.map

package/lib/private/orm/StoreInput.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StoreInput.js.map

package/lib/private/orm/key.d.ts

@@ -0,0 +1,8 @@
+import ForeignKey from "#orm/ForeignKey";
+import PrimaryKey from "#orm/PrimaryKey";
+declare const key: {
+    foreign: typeof ForeignKey.new;
+    primary: typeof PrimaryKey.new;
+};
+export default key;
+//# sourceMappingURL=key.d.ts.map

package/lib/private/orm/key.js

@@ -0,0 +1,8 @@
+import ForeignKey from "#orm/ForeignKey";
+import PrimaryKey from "#orm/PrimaryKey";
+const key = {
+    foreign: ForeignKey.new,
+    primary: PrimaryKey.new,
+};
+export default key;
+//# sourceMappingURL=key.js.map

package/lib/private/orm/parse.d.ts

@@ -0,0 +1,13 @@
+import type PK from "#db/PK";
+import ForeignKey from "#orm/ForeignKey";
+import type { AllowedFKType } from "#orm/ForeignKey";
+import type StoreInput from "#orm/StoreInput";
+import type { Dict } from "@rcompat/type";
+import type { Storable } from "pema";
+export default function parse(input: StoreInput): {
+    pk: PK;
+    generate_pk: boolean;
+    fks: Map<string, ForeignKey<AllowedFKType>>;
+    schema: Dict<Storable<keyof import("pema").DataType, unknown>>;
+};
+//# sourceMappingURL=parse.d.ts.map

package/lib/private/orm/parse.js

@@ -0,0 +1,29 @@
+import E from "#db/errors";
+import ForeignKey from "#orm/ForeignKey";
+import PrimaryKey from "#orm/PrimaryKey";
+const is_pk = (x) => x instanceof PrimaryKey;
+const is_fk = (x) => x instanceof ForeignKey;
+export default function parse(input) {
+    let pk = null;
+    let generate_pk = true;
+    const fks = new Map();
+    const schema = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (is_pk(value)) {
+            if (pk !== null)
+                throw E.pk_multiple_pks(pk, key);
+            pk = key;
+            generate_pk = value.generate;
+            schema[key] = value.type;
+        }
+        else if (is_fk(value)) {
+            fks.set(key, value);
+            schema[key] = value.type;
+        }
+        else {
+            schema[key] = value;
+        }
+    }
+    return { pk, generate_pk, fks, schema };
+}
+//# sourceMappingURL=parse.js.map

package/lib/private/orm/relation.d.ts

@@ -0,0 +1,43 @@
+import type { Store } from "#orm/store";
+import type StoreInput from "#orm/StoreInput";
+/**
+ * extracts schema type from either a schema or a Store.
+ */
+type SchemaOf<T> = T extends Store<infer S, any> ? S : T;
+/**
+ * One relation (singular) - returns single record or null
+ *
+ * Normal: FK is on the OTHER table, pointing to this table's PK.
+ *   Author has one Profile -> Profile has author_id
+ *
+ * Reverse: FK is on THIS table, pointing to other table's PK.
+ *   Profile belongs to Author -> Profile has author_id
+ */
+export type OneRelation<T extends StoreInput, FK extends string> = {
+    type: "one";
+    schema: T;
+    fk: FK;
+    reverse: boolean;
+};
+/**
+ * Many relation (plural) - returns array of records
+ *
+ * FK is always on the OTHER table, pointing to this table's PK.
+ *   Example: Author has many Articles → Article has author_id
+ */
+export type ManyRelation<T extends StoreInput, FK extends string> = {
+    type: "many";
+    schema: T;
+    fk: FK;
+};
+export type Relation = OneRelation<any, string> | ManyRelation<any, string>;
+declare function one<T extends StoreInput | Store<StoreInput, any>, FK extends string>(input: T, fk: FK, options?: {
+    reverse?: boolean;
+}): OneRelation<SchemaOf<T>, FK>;
+declare function many<T extends StoreInput | Store<StoreInput, any>, FK extends string>(input: T, fk: FK): ManyRelation<SchemaOf<T>, FK>;
+declare const _default: {
+    one: typeof one;
+    many: typeof many;
+};
+export default _default;
+//# sourceMappingURL=relation.d.ts.map

package/lib/private/orm/relation.js

@@ -0,0 +1,26 @@
+import is from "@rcompat/is";
+function is_store(value) {
+    return is.dict(value) && "schema" in value && is.function(value.get);
+}
+function extract_schema(schema_or_store) {
+    return (is_store(schema_or_store)
+        ? schema_or_store.schema
+        : schema_or_store);
+}
+function one(input, fk, options) {
+    return {
+        type: "one",
+        schema: extract_schema(input),
+        fk,
+        reverse: options?.reverse ?? false,
+    };
+}
+function many(input, fk) {
+    return {
+        type: "many",
+        schema: extract_schema(input),
+        fk,
+    };
+}
+export default { one, many };
+//# sourceMappingURL=relation.js.map

package/lib/private/orm/store.d.ts

@@ -0,0 +1,187 @@
+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 { DefaultType, InferStore, Storable } from "pema";
+import StoreType from "pema/StoreType";
+type X<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type OrNull<T> = {
+    [P in keyof T]?: null | T[P];
+};
+type StringOperators = {
+    $like?: string;
+    $ilike?: string;
+};
+type NumberOperators = {
+    $gt?: number;
+    $gte?: number;
+    $lt?: number;
+    $lte?: number;
+    $ne?: number;
+};
+type BigIntOperators = {
+    $gt?: bigint;
+    $gte?: bigint;
+    $lt?: bigint;
+    $lte?: bigint;
+    $ne?: bigint;
+};
+type DateOperators = {
+    $before?: Date;
+    $after?: Date;
+    $ne?: 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>>;
+type Schema<T extends StoreInput> = X<InferRecord<T>>;
+type Where<T extends StoreInput> = X<{
+    [K in keyof Schema<T>]?: QueryOperators<Schema<T>[K]>;
+}>;
+type $Set<T extends StoreInput> = X<OrNull<InferStore<ExtractSchema<T>>>>;
+type SelectKey<T> = Extract<keyof T, string>;
+type Select<T> = readonly SelectKey<T>[];
+type Sort<T> = Partial<Record<SelectKey<T>, "asc" | "desc">>;
+type Projected<T, S extends Select<T> | undefined> = S extends readonly (keyof T)[] ? X<Pick<T, S[number]>> : T;
+type DefaultFields<T extends StoreInput> = {
+    [K in keyof InferRecord<T>]: T[K] extends DefaultType<any, any> ? K : never;
+}[keyof InferRecord<T>];
+type Insertable<T extends StoreInput> = Omit<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>> & Partial<Pick<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>>>;
+type PrimaryKeyField<T extends StoreInput> = {
+    [K in keyof T]: T[K] extends PrimaryKey<any> ? K : never;
+}[keyof T] & keyof InferRecord<T>;
+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;
+    schema: S;
+    relations?: R;
+    migrate?: boolean;
+    extend?: Dict;
+};
+/**
+ * Database-backed store.
+ *
+ * A `Store` exposes a typed, validated interface over a relational or
+ * 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 {
+    #private;
+    readonly Schema: Schema<T>;
+    constructor(init: Init<T, R>);
+    get table(): {
+        create: () => import("@rcompat/type").MaybePromise<void>;
+        delete: () => import("@rcompat/type").MaybePromise<void>;
+    };
+    get infer(): InferRecord<T>;
+    get schema(): Dict<Storable<keyof import("pema").DataType, unknown>>;
+    get type(): StoreType<ExtractSchema<T>>;
+    get migrate(): boolean;
+    get name(): string;
+    get pk(): PK;
+    get db(): DB;
+    get types(): Types;
+    /**
+     * Count records
+     */
+    count(options?: {
+        where?: Where<T>;
+    }): Promise<number>;
+    /**
+     * Check whether a record with the given primary key exists.
+     */
+    has(pkv: PKV<T>): Promise<boolean>;
+    /**
+     * Get a record by primary key.
+     *
+     * - Without options: returns the full base record.
+     * - With `select`: returns a projected record.
+     * - 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: {
+        select?: S;
+        with?: W;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, R, 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: {
+        select?: S;
+        with?: W;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, R, W> | undefined>;
+    /**
+     * Insert a single record.
+     */
+    insert(record: Insertable<T>): Promise<Schema<T>>;
+    /**
+     * Update a single record by primary key.
+     */
+    update(pkv: PKV<T>, options: {
+        set: $Set<T>;
+    }): Promise<void>;
+    /**
+     * Update multiple records (requires non-empty where).
+     */
+    update(options: {
+        where?: Where<T>;
+        set: $Set<T>;
+    }): Promise<number>;
+    /**
+     * Delete a single record by primary key.
+     */
+    delete(pkv: PKV<T>): Promise<void>;
+    /**
+     * Delete multiple records (requires non-empty where).
+     */
+    delete(options: {
+        where: Where<T>;
+    }): Promise<number>;
+    /**
+     * Find matching records
+     *
+     */
+    find<const S extends Select<Schema<T>> | undefined = undefined, const W extends With<R> | undefined = undefined>(options?: {
+        where?: Where<T>;
+        select?: S;
+        sort?: Sort<Schema<T>>;
+        limit?: number;
+        with?: W;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, R, 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