cloesce 0.0.5-unstable.4 → 0.0.5-unstable.6

package/dist/router/crud.d.ts

@@ -1,7 +1,6 @@
-import { D1Database } from "@cloudflare/workers-types/experimental/index.js";
 /**
  * Wraps an object in a Proxy that will intercept non-overriden CRUD methods,
  * calling a default implementation.
  */
-export declare function proxyCrud(obj: any, ctor: any, d1: D1Database): any;
+export declare function proxyCrud(obj: any, ctor: any, env: any): any;
 //# sourceMappingURL=crud.d.ts.map

package/dist/router/crud.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/router/crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iDAAiD,CAAC;AAK7E;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,UAAU,OAyB5D"}
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/router/crud.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,OAyBtD"}

package/dist/router/crud.js

@@ -1,11 +1,11 @@
-import { Orm } from "../ui/backend.js";
-import { HttpResult } from "../ui/common.js";
+import { Orm, HttpResult } from "../ui/backend.js";
 import { NO_DATA_SOURCE } from "../ast.js";
+import { RuntimeContainer } from "./router.js";
 /**
  * Wraps an object in a Proxy that will intercept non-overriden CRUD methods,
  * calling a default implementation.
  */
-export function proxyCrud(obj, ctor, d1) {
+export function proxyCrud(obj, ctor, env) {
     return new Proxy(obj, {
         get(target, method) {
             // If the instance defines the method, always use it (override allowed)
@@ -15,44 +15,53 @@ export function proxyCrud(obj, ctor, d1) {
             }
             // Fallback to CRUD methods
             if (method === "save") {
-                return (body, ds) => upsert(ctor, body, ds, d1);
+                return (body, ds) => upsert(ctor, body, ds, env);
             }
             if (method === "list") {
-                return (ds) => list(ctor, ds, d1);
+                return (ds) => list(ctor, ds, env);
             }
             if (method === "get") {
-                return (id, ds) => _get(ctor, id, ds, d1);
+                return (...args) => _get(ctor, args, env);
             }
             return value;
         },
     });
 }
-async function upsert(ctor, body, dataSource, d1) {
+async function upsert(ctor, body, dataSource, env) {
     const includeTree = findIncludeTree(dataSource, ctor);
-    const orm = Orm.fromD1(d1);
+    const orm = Orm.fromEnv(env);
+    // Upsert
     const result = await orm.upsert(ctor, body, includeTree);
-    if (result.isLeft())
-        return HttpResult.fail(500, result.value);
-    const getRes = await orm.get(ctor, result.value, includeTree);
-    return getRes.isRight()
-        ? HttpResult.ok(200, getRes.value)
-        : HttpResult.fail(500, getRes.value);
+    return !result ? HttpResult.fail(404) : HttpResult.ok(200, result);
 }
-async function _get(ctor, id, dataSource, d1) {
-    const includeTree = findIncludeTree(dataSource, ctor);
-    const orm = Orm.fromD1(d1);
-    const res = await orm.get(ctor, id, includeTree);
-    return res.isRight()
-        ? HttpResult.ok(200, res.value)
-        : HttpResult.fail(500, res.value);
+async function _get(ctor, args, env) {
+    const { ast } = RuntimeContainer.get();
+    const model = ast.models[ctor.name];
+    const getArgs = {};
+    let argIndex = 0;
+    if (model.primary_key) {
+        // If there is a primary key, the first argument is the primary key.
+        getArgs.id = args[argIndex++];
+    }
+    if (model.key_params.length > 0) {
+        // All key params come after the primary key.
+        // Order is guaranteed by the compiler.
+        getArgs.keyParams = {};
+        for (const keyParam of model.key_params) {
+            getArgs.keyParams[keyParam] = args[argIndex++];
+        }
+    }
+    // The last argument is always the data source.
+    getArgs.includeTree = findIncludeTree(args[argIndex], ctor);
+    const orm = Orm.fromEnv(env);
+    const result = await orm.get(ctor, getArgs);
+    return !result ? HttpResult.fail(404) : HttpResult.ok(200, result);
 }
-async function list(ctor, dataSource, d1) {
+async function list(ctor, dataSource, env) {
     const includeTree = findIncludeTree(dataSource, ctor);
-    const orm = Orm.fromD1(d1);
-    const res = await orm.list(ctor, { includeTree });
-    return res.isRight()
-        ? HttpResult.ok(200, res.value)
-        : HttpResult.fail(500, res.value);
+    const orm = Orm.fromEnv(env);
+    const result = await orm.list(ctor, includeTree);
+    return HttpResult.ok(200, result);
 }
 function findIncludeTree(dataSource, ctor) {
     const normalizedDs = dataSource === NO_DATA_SOURCE ? null : dataSource;

package/dist/router/orm.d.ts

@@ -0,0 +1,66 @@
+import type { D1Result } from "@cloudflare/workers-types";
+import { IncludeTree, DeepPartial } from "../ui/backend.js";
+export declare class Orm {
+    private env;
+    private constructor();
+    /**
+     * Creates an instance of an `Orm`
+     * @param env The Wrangler environment containing Cloudflare bindings.
+     */
+    static fromEnv(env: unknown): Orm;
+    private get db();
+    /**
+     * Maps D1 results into model instances. Capable of mapping a flat result set
+     * (ie, SELECT * FROM Model) or a joined result granted it is aliased as `select_model` would produce.
+     *
+     * Does not hydrate into an instance of the model; for that, use `hydrate` after mapping.
+     *
+     * @example
+     * ```ts
+     * const d1Result = await db.prepare("SELECT * FROM User").all();
+     * const users: User[] = Orm.map(User, d1Result.results);
+     * ```
+     *
+     * @example
+     * ```ts
+     * const d1Result = await db.prepare(`
+     *  ${Orm.select(User, null, { posts: {} })}
+     *  WHERE User.id = ?
+     * `).bind(1).all();
+     *
+     * const users: User[] = Orm.map(User, d1Result.results, { posts: {} });
+     * ```
+     *
+     * @param ctor Constructor of the model to map to
+     * @param d1Results Results from a D1 query
+     * @param includeTree Include tree specifying which navigation properties to include
+     * @returns Array of mapped model instances
+     */
+    static map<T extends object>(ctor: new () => T, d1Results: D1Result, includeTree?: IncludeTree<T> | null): T[];
+    static select<T extends object>(ctor: new () => T, args?: {
+        from?: string | null;
+        includeTree?: IncludeTree<T> | null;
+    }): string;
+    hydrate<T extends object>(ctor: new () => T, args?: {
+        base?: any;
+        keyParams?: Record<string, string>;
+        includeTree?: IncludeTree<T> | null;
+    }): Promise<T>;
+    upsert<T extends object>(ctor: new () => T, newModel: DeepPartial<T>, includeTree?: IncludeTree<T> | null): Promise<T | null>;
+    list<T extends object>(ctor: new () => T, includeTree?: IncludeTree<T> | null): Promise<T[]>;
+    /**
+     * Fetches a model by its primary key ID or key parameters.
+     * * If the model does not have a primary key, key parameters must be provided.
+     * * If the model has a primary key, the ID must be provided.
+     *
+     * @param ctor Constructor of the model to retrieve
+     * @param args Arguments for retrieval
+     * @returns The retrieved model instance, or `null` if not found
+     */
+    get<T extends object>(ctor: new () => T, args?: {
+        id?: any;
+        keyParams?: Record<string, string>;
+        includeTree?: IncludeTree<T> | null;
+    }): Promise<T | null>;
+}
+//# sourceMappingURL=orm.d.ts.map

package/dist/router/orm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orm.d.ts","sourceRoot":"","sources":["../../src/router/orm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,QAAQ,EACT,MAAM,2BAA2B,CAAC;AAMnC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAU,MAAM,kBAAkB,CAAC;AAEpE,qBAAa,GAAG;IACM,OAAO,CAAC,GAAG;IAA/B,OAAO;IAEP;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG;IAOjC,OAAO,KAAK,EAAE,GAGb;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,MAAM,EACzB,IAAI,EAAE,UAAU,CAAC,EACjB,SAAS,EAAE,QAAQ,EACnB,WAAW,GAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAW,GACxC,CAAC,EAAE;IAyBN,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,MAAM,EAC5B,IAAI,EAAE,UAAU,CAAC,EACjB,IAAI,GAAE;QACJ,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KAIrC,GACA,MAAM;IA0BH,OAAO,CAAC,CAAC,SAAS,MAAM,EAC5B,IAAI,EAAE,UAAU,CAAC,EACjB,IAAI,GAAE;QACJ,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KAKrC,GACA,OAAO,CAAC,CAAC,CAAC;IAkNP,MAAM,CAAC,CAAC,SAAS,MAAM,EAC3B,IAAI,EAAE,UAAU,CAAC,EACjB,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EACxB,WAAW,GAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAW,GACxC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAqLd,IAAI,CAAC,CAAC,SAAS,MAAM,EACzB,IAAI,EAAE,UAAU,CAAC,EACjB,WAAW,GAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAW,GACxC,OAAO,CAAC,CAAC,EAAE,CAAC;IAqCf;;;;;;;;OAQG;IACG,GAAG,CAAC,CAAC,SAAS,MAAM,EACxB,IAAI,EAAE,UAAU,CAAC,EACjB,IAAI,GAAE;QACJ,EAAE,CAAC,EAAE,GAAG,CAAC;QACT,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KAKrC,GACA,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CA2CrB"}

package/dist/router/orm.js

@@ -0,0 +1,447 @@
+import { RuntimeContainer } from "../router/router.js";
+import { WasmResource, invokeOrmWasm } from "../router/wasm.js";
+import { InternalError, u8ToB64 } from "../common.js";
+import { KValue } from "../ui/backend.js";
+export class Orm {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    /**
+     * Creates an instance of an `Orm`
+     * @param env The Wrangler environment containing Cloudflare bindings.
+     */
+    static fromEnv(env) {
+        // TODO: We could validate that `env` is of the correct type defined by the `＠WranglerEnv` class
+        // by putting the class definition in the Constructor Registry at compile time.
+        return new Orm(env);
+    }
+    // TODO: support multiple D1 bindings
+    get db() {
+        const { ast } = RuntimeContainer.get();
+        return this.env[ast.wrangler_env.d1_binding];
+    }
+    /**
+     * Maps D1 results into model instances. Capable of mapping a flat result set
+     * (ie, SELECT * FROM Model) or a joined result granted it is aliased as `select_model` would produce.
+     *
+     * Does not hydrate into an instance of the model; for that, use `hydrate` after mapping.
+     *
+     * @example
+     * ```ts
+     * const d1Result = await db.prepare("SELECT * FROM User").all();
+     * const users: User[] = Orm.map(User, d1Result.results);
+     * ```
+     *
+     * @example
+     * ```ts
+     * const d1Result = await db.prepare(`
+     *  ${Orm.select(User, null, { posts: {} })}
+     *  WHERE User.id = ?
+     * `).bind(1).all();
+     *
+     * const users: User[] = Orm.map(User, d1Result.results, { posts: {} });
+     * ```
+     *
+     * @param ctor Constructor of the model to map to
+     * @param d1Results Results from a D1 query
+     * @param includeTree Include tree specifying which navigation properties to include
+     * @returns Array of mapped model instances
+     */
+    static map(ctor, d1Results, includeTree = null) {
+        const { wasm } = RuntimeContainer.get();
+        const d1ResultsRes = WasmResource.fromString(JSON.stringify(d1Results.results), wasm);
+        const includeTreeRes = WasmResource.fromString(JSON.stringify(includeTree), wasm);
+        const mapQueryRes = invokeOrmWasm(wasm.map, [WasmResource.fromString(ctor.name, wasm), d1ResultsRes, includeTreeRes], wasm);
+        if (mapQueryRes.isLeft()) {
+            throw new InternalError(`Mapping failed: ${mapQueryRes.value}`);
+        }
+        return JSON.parse(mapQueryRes.unwrap());
+    }
+    // Given a model, generates a sequence of joins to select it with its includes.
+    static select(ctor, args = {
+        from: null,
+        includeTree: null,
+    }) {
+        const { wasm } = RuntimeContainer.get();
+        const fromRes = WasmResource.fromString(JSON.stringify(args.from ?? null), wasm);
+        const includeTreeRes = WasmResource.fromString(JSON.stringify(args.includeTree ?? null), wasm);
+        const selectQueryRes = invokeOrmWasm(wasm.select_model, [WasmResource.fromString(ctor.name, wasm), fromRes, includeTreeRes], wasm);
+        if (selectQueryRes.isLeft()) {
+            throw new InternalError(`Select generation failed: ${selectQueryRes.value}`);
+        }
+        return selectQueryRes.unwrap();
+    }
+    async hydrate(ctor, args = {
+        base: {},
+        keyParams: {},
+        includeTree: null,
+    }) {
+        const { ast, constructorRegistry } = RuntimeContainer.get();
+        const model = ast.models[ctor.name];
+        if (!model) {
+            return args.base ?? {};
+        }
+        const env = this.env;
+        const instance = Object.assign(new constructorRegistry[model.name](), args.base);
+        const promises = [];
+        recurse(instance, model, args.includeTree ?? {});
+        await Promise.all(promises);
+        return instance;
+        async function hydrateKVList(namespace, key, kv, current) {
+            const res = await namespace.list({ prefix: key });
+            if (kv.value.cidl_type === "Stream") {
+                current[kv.value.name] = await Promise.all(res.keys.map(async (k) => {
+                    const stream = await namespace.get(k.name, { type: "stream" });
+                    return Object.assign(new KValue(), {
+                        key: k.name,
+                        raw: stream,
+                        metadata: null,
+                    });
+                }));
+            }
+            else {
+                current[kv.value.name] = await Promise.all(res.keys.map(async (k) => {
+                    const kvRes = await namespace.getWithMetadata(k.name, {
+                        type: "json",
+                    });
+                    return Object.assign(new KValue(), {
+                        key: k.name,
+                        raw: kvRes.value,
+                        metadata: kvRes.metadata,
+                    });
+                }));
+            }
+        }
+        async function hydrateKVSingle(namespace, key, kv, current) {
+            if (kv.value.cidl_type === "Stream") {
+                const res = await namespace.get(key, { type: "stream" });
+                current[kv.value.name] = Object.assign(new KValue(), {
+                    key,
+                    raw: res,
+                    metadata: null,
+                });
+            }
+            else {
+                const res = await namespace.getWithMetadata(key, { type: "json" });
+                current[kv.value.name] = Object.assign(new KValue(), {
+                    key,
+                    raw: res.value,
+                    metadata: res.metadata,
+                });
+            }
+        }
+        function recurse(current, meta, includeTree) {
+            // Hydrate navigation properties
+            for (const navProp of meta.navigation_properties) {
+                const nestedTree = includeTree[navProp.var_name];
+                if (!nestedTree)
+                    continue;
+                const nestedMeta = ast.models[navProp.model_reference];
+                const value = current[navProp.var_name];
+                if (Array.isArray(value)) {
+                    const ctor = constructorRegistry[nestedMeta.name];
+                    current[navProp.var_name] = value.map((child) => {
+                        const instance = Object.assign(new ctor(), child);
+                        recurse(instance, nestedMeta, nestedTree);
+                        return instance;
+                    });
+                }
+                else if (value) {
+                    current[navProp.var_name] = Object.assign(new constructorRegistry[nestedMeta.name](), value);
+                    recurse(current[navProp.var_name], nestedMeta, nestedTree);
+                }
+            }
+            // Hydrate columns
+            for (const col of meta.columns) {
+                if (current[col.value.name] === undefined) {
+                    continue;
+                }
+                switch (col.value.cidl_type) {
+                    case "DateIso": {
+                        current[col.value.name] = new Date(current[col.value.name]);
+                        break;
+                    }
+                    case "Blob": {
+                        const arr = current[col.value.name];
+                        current[col.value.name] = new Uint8Array(arr);
+                    }
+                    default: {
+                        break;
+                    }
+                }
+            }
+            // Hydrate key params
+            if (args.keyParams) {
+                for (const keyParam of meta.key_params) {
+                    current[keyParam] = args.keyParams[keyParam];
+                }
+            }
+            // Hydrate KV objects
+            for (const kv of meta.kv_objects) {
+                // Include check
+                if (includeTree[kv.value.name] === undefined) {
+                    if (kv.list_prefix) {
+                        current[kv.value.name] = [];
+                    }
+                    continue;
+                }
+                const key = resolveKey(kv.format, current, args.keyParams ?? {});
+                if (!key) {
+                    if (kv.list_prefix) {
+                        current[kv.value.name] = [];
+                    }
+                    // All key params must be resolvable.
+                    // Fail silently by skipping hydration.
+                    continue;
+                }
+                const namespace = env[kv.namespace_binding];
+                if (kv.list_prefix) {
+                    promises.push(hydrateKVList(namespace, key, kv, current));
+                }
+                else {
+                    promises.push(hydrateKVSingle(namespace, key, kv, current));
+                }
+            }
+            // Hydrate R2 objects
+            for (const r2 of meta.r2_objects) {
+                if (includeTree[r2.var_name] === undefined) {
+                    if (r2.list_prefix) {
+                        current[r2.var_name] = [];
+                    }
+                    continue;
+                }
+                const key = resolveKey(r2.format, current, args.keyParams ?? {});
+                if (!key) {
+                    if (r2.list_prefix) {
+                        current[r2.var_name] = [];
+                    }
+                    // All key params must be resolvable.
+                    // Fail silently by skipping hydration.
+                    continue;
+                }
+                const bucket = env[r2.bucket_binding];
+                if (r2.list_prefix) {
+                    promises.push((async () => {
+                        const list = await bucket.list({ prefix: key });
+                        current[r2.var_name] = await Promise.all(list.objects.map(async (obj) => {
+                            const fullObj = await bucket.get(obj.key);
+                            return fullObj;
+                        }));
+                    })());
+                }
+                else {
+                    promises.push((async () => {
+                        const obj = await bucket.get(key);
+                        current[r2.var_name] = obj;
+                    })());
+                }
+            }
+        }
+    }
+    async upsert(ctor, newModel, includeTree = null) {
+        const { wasm, ast } = RuntimeContainer.get();
+        const meta = ast.models[ctor.name];
+        const upsertQueryRes = invokeOrmWasm(wasm.upsert_model, [
+            WasmResource.fromString(ctor.name, wasm),
+            WasmResource.fromString(
+            // TODO: Stringify only objects in the include tree?
+            // Could try to track `this` in the reviver function
+            JSON.stringify(newModel, (_, v) => 
+            // To serialize a Uint8Array s.t. WASM can read it, we convert it to a base64 string.
+            v instanceof Uint8Array ? u8ToB64(v) : v), wasm),
+            WasmResource.fromString(JSON.stringify(includeTree), wasm),
+        ], wasm);
+        if (upsertQueryRes.isLeft()) {
+            throw new InternalError(`Upsert failed: ${upsertQueryRes.value}`);
+        }
+        const res = JSON.parse(upsertQueryRes.unwrap());
+        const kvUploadPromises = res.kv_uploads.map(async (upload) => {
+            const namespace = this.env[upload.namespace_binding];
+            if (!namespace) {
+                throw new InternalError(`KV Namespace binding "${upload.namespace_binding}" not found for upsert.`);
+            }
+            await namespace.put(upload.key, JSON.stringify(upload.value), {
+                metadata: upload.metadata,
+            });
+        });
+        const queries = res.sql.map((s) => this.db.prepare(s.query).bind(...s.values));
+        // Concurrently execute SQL with KV uploads.
+        const [batchRes] = await Promise.all([
+            queries.length > 0 ? this.db.batch(queries) : Promise.resolve([]),
+            ...kvUploadPromises,
+        ]);
+        let base = {};
+        if (queries.length > 0) {
+            const failed = batchRes.find((r) => !r.success);
+            if (failed) {
+                // An error in the upsert should not be possible unless the AST is invalid.
+                throw new InternalError(`Upsert failed during execution: ${failed.error}`);
+            }
+            // A SELECT statement towards the end will call `select_model` to retrieve the upserted model.
+            let selectIndex;
+            for (let i = res.sql.length - 1; i >= 0; i--) {
+                if (/^SELECT/i.test(res.sql[i].query)) {
+                    selectIndex = i;
+                    break;
+                }
+            }
+            base = Orm.map(ctor, batchRes[selectIndex], includeTree)[0];
+        }
+        // Base needs to include all of the key params from newModel and its includes.
+        const q = [
+            { model: base, meta, tree: includeTree ?? {} },
+        ];
+        while (q.length > 0) {
+            const { model: currentModel, meta: currentMeta, tree: currentTree, } = q.shift();
+            // Key params
+            for (const keyParam of currentMeta.key_params) {
+                if (currentModel[keyParam] === undefined) {
+                    currentModel[keyParam] = newModel[keyParam];
+                }
+            }
+            // Navigation properties
+            for (const navProp of currentMeta.navigation_properties) {
+                const nestedTree = currentTree[navProp.var_name];
+                if (!nestedTree)
+                    continue;
+                const nestedMeta = ast.models[navProp.model_reference];
+                const value = currentModel[navProp.var_name];
+                if (Array.isArray(value)) {
+                    for (let i = 0; i < value.length; i++) {
+                        q.push({
+                            model: value[i],
+                            meta: nestedMeta,
+                            tree: nestedTree,
+                        });
+                    }
+                }
+                else if (value) {
+                    q.push({
+                        model: value,
+                        meta: nestedMeta,
+                        tree: nestedTree,
+                    });
+                }
+            }
+        }
+        // Upload all delayed KV uploads
+        await Promise.all(res.kv_delayed_uploads.map(async (upload) => {
+            let current = base;
+            for (const pathPart of upload.path) {
+                current = current[pathPart];
+                if (current === undefined) {
+                    throw new InternalError(`Failed to resolve path ${upload.path.join(".")} for delayed KV upload.`);
+                }
+            }
+            const namespace = this.env[upload.namespace_binding];
+            if (!namespace) {
+                throw new InternalError(`KV Namespace binding "${upload.namespace_binding}" not found for upsert.`);
+            }
+            const key = resolveKey(upload.key, current, {});
+            if (!key) {
+                throw new InternalError(`Failed to resolve key format "${upload.key}" for delayed KV upload.`);
+            }
+            await namespace.put(key, JSON.stringify(upload.value), {
+                metadata: upload.metadata,
+            });
+        }));
+        // Hydrate and return the upserted model
+        return await this.hydrate(ctor, {
+            base: base,
+            includeTree,
+        });
+    }
+    async list(ctor, includeTree = null) {
+        const { ast } = RuntimeContainer.get();
+        const model = ast.models[ctor.name];
+        if (!model) {
+            return [];
+        }
+        if (model.primary_key === null) {
+            // Listing is not supported for models without primary keys (i.e., KV or R2 only).
+            return [];
+        }
+        const query = Orm.select(ctor, {
+            includeTree,
+        });
+        const rows = await this.db.prepare(query).all();
+        if (rows.error) {
+            // An error in the query should not be possible unless the AST is invalid.
+            throw new InternalError(`Failed to list models for ${ctor.name}: ${rows.error}`);
+        }
+        // Map and hydrate
+        const results = Orm.map(ctor, rows, includeTree);
+        await Promise.all(results.map(async (modelJson, index) => {
+            results[index] = await this.hydrate(ctor, {
+                base: modelJson,
+                includeTree,
+            });
+        }));
+        return results;
+    }
+    /**
+     * Fetches a model by its primary key ID or key parameters.
+     * * If the model does not have a primary key, key parameters must be provided.
+     * * If the model has a primary key, the ID must be provided.
+     *
+     * @param ctor Constructor of the model to retrieve
+     * @param args Arguments for retrieval
+     * @returns The retrieved model instance, or `null` if not found
+     */
+    async get(ctor, args = {
+        id: undefined,
+        keyParams: {},
+        includeTree: null,
+    }) {
+        const { ast } = RuntimeContainer.get();
+        const model = ast.models[ctor.name];
+        if (!model) {
+            return null;
+        }
+        // KV or R2 only
+        if (model.primary_key === null) {
+            return await this.hydrate(ctor, {
+                keyParams: args.keyParams,
+                includeTree: args.includeTree ?? null,
+            });
+        }
+        // D1 retrieval
+        const pkName = model.primary_key.name;
+        const query = `
+      ${Orm.select(ctor, { includeTree: args.includeTree })}
+      WHERE  "${model.name}"."${pkName}" = ?
+    `;
+        const rows = await this.db.prepare(query).bind(args.id).run();
+        if (rows.error) {
+            // An error in the query should not be possible unless the AST is invalid.
+            throw new InternalError(`Failed to retrieve model ${ctor.name} with ${pkName}=${args.id}: ${rows.error}`);
+        }
+        if (rows.results.length < 1) {
+            return null;
+        }
+        // Map and hydrate
+        const results = Orm.map(ctor, rows, args.includeTree ?? null);
+        return await this.hydrate(ctor, {
+            base: results.at(0),
+            keyParams: args.keyParams,
+            includeTree: args.includeTree ?? null,
+        });
+    }
+}
+/**
+ * @returns null if any parameter could not be resolved
+ */
+function resolveKey(format, current, keyParams) {
+    try {
+        return format.replace(/\{([^}]+)\}/g, (_, paramName) => {
+            const paramValue = keyParams[paramName] ?? current[paramName];
+            if (!paramValue)
+                throw null;
+            return String(paramValue);
+        });
+    }
+    catch {
+        return null;
+    }
+}