@snowtop/ent 0.2.7 → 0.2.8

package/core/dev_schema.js

@@ -0,0 +1,306 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDevSchema = resolveDevSchema;
+exports.isDevSchemaEnabled = isDevSchemaEnabled;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const STATE_DIR = ".ent";
+const STATE_FILE = "dev_schema.json";
+const DEFAULT_SCHEMA_DIR = path.join("src", "schema");
+const DEFAULT_SCHEMA_PREFIX = "ent_dev";
+const MAX_SCHEMA_LEN = 63;
+function resolveDevSchema(cfg) {
+    if (!isDevSchemaEnabled(cfg)) {
+        return { enabled: false };
+    }
+    if (cfg?.schemaName) {
+        const schemaName = sanitizeIdentifier(cfg.schemaName);
+        return {
+            enabled: true,
+            schemaName,
+            includePublic: cfg.includePublic === true,
+        };
+    }
+    if (cfg) {
+        const branchName = requireCurrentBranch("dev branch schemas are enabled but the current git branch could not be determined. Set devSchema.schemaName explicitly.");
+        return {
+            enabled: true,
+            schemaName: buildSchemaName(branchName),
+            branchName,
+            includePublic: cfg.includePublic === true,
+        };
+    }
+    const state = loadDevSchemaState(resolveStatePath());
+    if (state?.schemaName) {
+        const branchName = state.branchName;
+        if (branchName) {
+            // State-file mode is tied to the branch that produced the generated
+            // schema metadata. Fail closed after branch switches until codegen
+            // refreshes the state file.
+            const currentBranch = requireCurrentBranch(`dev branch schema state was generated for branch "${branchName}" but the current git branch could not be determined. Run ent codegen to regenerate or set devSchema.schemaName explicitly.`);
+            if (currentBranch !== branchName) {
+                throw new Error(`dev branch schema state was generated for branch "${branchName}" but current branch is "${currentBranch}". Run ent codegen to regenerate or set devSchema.schemaName explicitly.`);
+            }
+        }
+        return {
+            enabled: true,
+            schemaName: sanitizeIdentifier(state.schemaName),
+            branchName,
+            includePublic: state.includePublic === true,
+        };
+    }
+    const branchName = requireCurrentBranch("dev branch schemas are enabled but the current git branch could not be determined. Set devSchema.schemaName explicitly or run ent codegen to regenerate src/schema/.ent/dev_schema.json.");
+    return {
+        enabled: true,
+        schemaName: buildSchemaName(branchName),
+        branchName,
+        includePublic: false,
+    };
+}
+function isDevSchemaEnabled(cfg) {
+    const nodeEnv = (process.env.NODE_ENV || "").toLowerCase();
+    if (nodeEnv === "production") {
+        return false;
+    }
+    const envEnabled = parseEnvBool("ENT_DEV_SCHEMA_ENABLED");
+    if (envEnabled !== undefined) {
+        return envEnabled;
+    }
+    if (cfg) {
+        if (cfg.enabled !== true) {
+            return false;
+        }
+        const branch = resolveGitBranch();
+        if (isBranchIgnored(cfg.ignoreBranches, branch)) {
+            return false;
+        }
+        return true;
+    }
+    const state = loadDevSchemaState(resolveStatePath());
+    if (!state?.schemaName) {
+        return false;
+    }
+    const branch = resolveGitBranch();
+    if (isBranchIgnored(state.ignoreBranches, branch)) {
+        return false;
+    }
+    return true;
+}
+function loadDevSchemaState(statePath) {
+    if (!statePath || !fs.existsSync(statePath)) {
+        return undefined;
+    }
+    const raw = fs.readFileSync(statePath, "utf8");
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`invalid dev schema state file at ${statePath}`);
+    }
+    if (!data || !data.schemaName) {
+        return undefined;
+    }
+    return data;
+}
+function requireCurrentBranch(message) {
+    const branch = resolveGitBranch();
+    if (!branch) {
+        throw new Error(message);
+    }
+    return branch;
+}
+function slugify(input) {
+    if (!input) {
+        return "";
+    }
+    const lower = input.toLowerCase();
+    let out = "";
+    let lastUnderscore = false;
+    for (const ch of lower) {
+        const isAlpha = ch >= "a" && ch <= "z";
+        const isDigit = ch >= "0" && ch <= "9";
+        if (isAlpha || isDigit) {
+            out += ch;
+            lastUnderscore = false;
+            continue;
+        }
+        if (!lastUnderscore) {
+            out += "_";
+            lastUnderscore = true;
+        }
+    }
+    return trimBoundaryUnderscores(out);
+}
+function trimBoundaryUnderscores(input) {
+    let start = 0;
+    let end = input.length;
+    while (start < end && input[start] === "_") {
+        start++;
+    }
+    while (end > start && input[end - 1] === "_") {
+        end--;
+    }
+    return input.slice(start, end);
+}
+function sanitizeIdentifier(input) {
+    const slug = slugify(input);
+    if (!slug) {
+        return "schema";
+    }
+    let normalized = slug;
+    if (normalized[0] >= "0" && normalized[0] <= "9") {
+        normalized = `schema_${normalized}`;
+    }
+    if (normalized.length > MAX_SCHEMA_LEN) {
+        return normalized.slice(0, MAX_SCHEMA_LEN);
+    }
+    return normalized;
+}
+function shortHash(input) {
+    return (0, crypto_1.createHash)("sha1").update(input).digest("hex").slice(0, 8);
+}
+function buildSchemaName(branch) {
+    const prefix = sanitizeIdentifier(DEFAULT_SCHEMA_PREFIX);
+    let branchSlug = slugify(branch);
+    if (!branchSlug) {
+        branchSlug = "branch";
+    }
+    const hash = shortHash(branch);
+    let name = [prefix, branchSlug, hash].join("_");
+    if (name.length <= MAX_SCHEMA_LEN) {
+        return name;
+    }
+    const over = name.length - MAX_SCHEMA_LEN;
+    if (over > 0 && branchSlug.length > 1) {
+        branchSlug = branchSlug.slice(0, branchSlug.length - Math.min(over, branchSlug.length - 1));
+    }
+    name = [prefix, branchSlug, hash].join("_");
+    if (name.length > MAX_SCHEMA_LEN) {
+        return name.slice(0, MAX_SCHEMA_LEN);
+    }
+    return name;
+}
+function resolveStatePath() {
+    const start = process.cwd();
+    const root = findGitRoot(start) || start;
+    const schemaDir = path.join(root, DEFAULT_SCHEMA_DIR);
+    return path.join(schemaDir, STATE_DIR, STATE_FILE);
+}
+function isBranchIgnored(ignoreBranches, branch) {
+    if (!branch || !ignoreBranches || ignoreBranches.length === 0) {
+        return false;
+    }
+    for (const name of ignoreBranches) {
+        if (!name || !name.trim()) {
+            continue;
+        }
+        if (name === branch) {
+            return true;
+        }
+    }
+    return false;
+}
+function parseEnvBool(key) {
+    const raw = process.env[key];
+    if (!raw) {
+        return undefined;
+    }
+    const val = raw.trim().toLowerCase();
+    if (["1", "true", "t", "yes", "y"].includes(val)) {
+        return true;
+    }
+    if (["0", "false", "f", "no", "n"].includes(val)) {
+        return false;
+    }
+    return undefined;
+}
+function resolveGitBranch() {
+    const start = process.cwd();
+    const root = findGitRoot(start);
+    if (!root) {
+        return "";
+    }
+    const gitDir = resolveGitDir(path.join(root, ".git"));
+    if (!gitDir) {
+        return "";
+    }
+    const headPath = path.join(gitDir, "HEAD");
+    if (!fs.existsSync(headPath)) {
+        return "";
+    }
+    const head = fs.readFileSync(headPath, "utf8").trim();
+    if (!head.startsWith("ref:")) {
+        return "";
+    }
+    return head
+        .replace("ref:", "")
+        .trim()
+        .replace(/^refs\/heads\//, "");
+}
+function resolveGitDir(gitPath) {
+    if (!fs.existsSync(gitPath)) {
+        return undefined;
+    }
+    const stat = fs.statSync(gitPath);
+    if (stat.isDirectory()) {
+        return gitPath;
+    }
+    const contents = fs.readFileSync(gitPath, "utf8").trim();
+    if (!contents.startsWith("gitdir:")) {
+        return undefined;
+    }
+    let dir = contents.replace("gitdir:", "").trim();
+    if (!path.isAbsolute(dir)) {
+        dir = path.join(path.dirname(gitPath), dir);
+    }
+    return dir;
+}
+function findGitRoot(start) {
+    let dir = start;
+    while (true) {
+        const gitPath = path.join(dir, ".git");
+        if (fs.existsSync(gitPath)) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return undefined;
+        }
+        dir = parent;
+    }
+}

package/core/ent.d.ts

@@ -1,4 +1,4 @@
-import { Context, CreateRowOptions, Data, DataOptions, EdgeQueryableDataOptions, EditRowOptions, Ent, ID, LoadCustomEntOptions, LoadEntOptions, LoadRowOptions, LoadRowsOptions, LoaderWithLoadMany, QueryDataOptions, SelectCustomDataOptions, Viewer } from "./base";
+import { Context, CreateRowOptions, Data, DataOptions, EdgeQueryableDataOptions, EditRowOptions, Ent, ID, LoadCustomEntOptions, LoadEntOptions, LoadRowOptions, LoadRowsOptions, LoaderWithLoadMany, QueryDataOptions, SelectBaseDataOptions, SelectCustomDataOptions, Viewer } from "./base";
 import { Queryer, SyncQueryer } from "./db";
 import * as clause from "./clause";
 import { InstrumentedDataLoader } from "./loaders/loader";
@@ -108,10 +108,7 @@ interface GroupQueryOptions<T extends Data, K = keyof T> {
     tableName: string;
     clause?: clause.Clause<T, K>;
     groupColumn: K;
-    fields: (K | {
-        alias: string;
-        column: K;
-    })[];
+    fields: SelectBaseDataOptions["fields"];
     values: any[];
     orderby?: OrderBy;
     limit: number;
@@ -151,6 +148,7 @@ export interface cursorOptions {
      */
     rowKeys?: string[];
 }
+export declare function decodeCursorPayload(encoded: string): string;
 export declare function getCursor(opts: cursorOptions): string;
 export declare class AssocEdgeData {
     edgeType: string;

package/core/ent.js

@@ -68,6 +68,7 @@ exports.editRow = editRow;
 exports.editRowSync = editRowSync;
 exports.deleteRows = deleteRows;
 exports.deleteRowsSync = deleteRowsSync;
+exports.decodeCursorPayload = decodeCursorPayload;
 exports.getCursor = getCursor;
 exports.loadEdgeData = loadEdgeData;
 exports.loadEdgeDatas = loadEdgeDatas;
@@ -607,13 +608,13 @@ async function loadRow(options) {
             return row;
         }
     }
-    const query = (0, query_impl_1.buildQuery)(options);
-    logQuery(query, options.clause.logValues());
+    const queryData = (0, query_impl_1.buildQueryData)(options);
+    logQuery(queryData.query, queryData.logValues);
     const pool = db_1.default.getInstance().getPool();
-    const res = await pool.query(query, options.clause.values());
+    const res = await pool.query(queryData.query, queryData.values);
     if (res.rowCount != 1) {
         if (res.rowCount > 1) {
-            (0, logger_1.log)("error", "got more than one row for query " + query);
+            (0, logger_1.log)("error", "got more than one row for query " + queryData.query);
         }
         return null;
     }
@@ -652,8 +653,8 @@ async function loadRows(options) {
             return rows;
         }
     }
-    const query = (0, query_impl_1.buildQuery)(options);
-    const r = await performRawQuery(query, options.clause.values(), options.clause.logValues());
+    const queryData = (0, query_impl_1.buildQueryData)(options);
+    const r = await performRawQuery(queryData.query, queryData.values, queryData.logValues);
     if (cache) {
         // put the rows in the cache...
         cache.primeCache(options, r);
@@ -662,6 +663,12 @@ async function loadRows(options) {
 }
 // this is used for queries when we select multiple ids at once
 function buildGroupQuery(options) {
+    if (options.fields.some((field) => typeof field === "object" && "expression" in field)) {
+        throw new Error("group queries do not support computed select expressions");
+    }
+    if (options.orderby && (0, query_impl_1.orderByHasExpressions)(options.orderby)) {
+        throw new Error("group queries do not support computed order expressions");
+    }
     const fields = [...options.fields, "row_number()"];
     let cls = clause.In(options.groupColumn, ...options.values);
     if (options.clause) {
@@ -900,6 +907,14 @@ class AssocEdge {
     }
 }
 exports.AssocEdge = AssocEdge;
+// UTF-8-safe cursor encoding (btoa only supports Latin-1 code units).
+function encodeCursorPayload(json) {
+    return Buffer.from(json, "utf8").toString("base64");
+}
+// Inverse of encodeCursorPayload; exported for pagination decode in query.ts
+function decodeCursorPayload(encoded) {
+    return Buffer.from(encoded, "base64").toString("utf8");
+}
 // TODO eventually update this for sortCol time unique keys
 function getCursor(opts) {
     const { row, cursorKeys, rowKeys } = opts;
@@ -917,7 +932,7 @@ function getCursor(opts) {
         const rowKey = rowKeys?.[i] || cursorKey;
         parts.push([cursorKey, convert(row[rowKey])]);
     }
-    return btoa(JSON.stringify(parts));
+    return encodeCursorPayload(JSON.stringify(parts));
 }
 class AssocEdgeData {
     constructor(data) {

package/core/extensions.d.ts

@@ -0,0 +1,25 @@
+import { type Pool } from "pg";
+import type { RuntimeDBExtension } from "./config";
+import type { ResolvedDevSchema } from "./dev_schema";
+export interface InstalledDBExtension {
+    name: string;
+    version: string;
+    installSchema?: string;
+}
+export interface ExtensionTypeParser {
+    name: string;
+    parse(value: string | null): unknown;
+}
+export interface ExtensionRuntimeHandler {
+    name: string;
+    runtimeSchemas?: string[];
+    types?: ExtensionTypeParser[];
+    validate?(installed: InstalledDBExtension, extension: RuntimeDBExtension): void | Promise<void>;
+}
+export declare function registerExtensionRuntime(handler: ExtensionRuntimeHandler): void;
+export declare function clearExtensionRuntimes(): void;
+export declare function normalizeExtensions(extensions: RuntimeDBExtension[]): RuntimeDBExtension[];
+export declare function resolveExtensions(cfg?: RuntimeDBExtension[]): RuntimeDBExtension[];
+export declare function getExtensionSearchPathSchemas(extensions: RuntimeDBExtension[]): string[];
+export declare function buildExtensionSearchPath(resolvedDevSchema: ResolvedDevSchema, extensions: RuntimeDBExtension[]): string | undefined;
+export declare function initializeExtensions(pool: Pick<Pool, "query">, extensions: RuntimeDBExtension[]): Promise<void>;

package/core/extensions.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerExtensionRuntime = registerExtensionRuntime;
+exports.clearExtensionRuntimes = clearExtensionRuntimes;
+exports.normalizeExtensions = normalizeExtensions;
+exports.resolveExtensions = resolveExtensions;
+exports.getExtensionSearchPathSchemas = getExtensionSearchPathSchemas;
+exports.buildExtensionSearchPath = buildExtensionSearchPath;
+exports.initializeExtensions = initializeExtensions;
+const pg_1 = require("pg");
+const TEXT_ARRAY_OID = 1009;
+const runtimeHandlers = new Map();
+const registeredTypeOIDs = new Set();
+function normalizeProvisionedBy(extension) {
+    if (extension.provisionedBy === "ent" ||
+        extension.provisionedBy === "external") {
+        return extension.provisionedBy;
+    }
+    if (extension.provisionedBy) {
+        throw new Error(`invalid provisionedBy ${extension.provisionedBy} for db extension ${extension.name}`);
+    }
+    return "ent";
+}
+function normalizeRuntimeHandler(handler) {
+    const typeHandlers = new Map();
+    for (const typeHandler of handler.types || []) {
+        typeHandlers.set(typeHandler.name, typeHandler);
+    }
+    return {
+        ...handler,
+        runtimeSchemas: [...new Set(handler.runtimeSchemas || [])],
+        types: [...typeHandlers.values()],
+    };
+}
+function mergeRuntimeHandlers(lhs, rhs) {
+    const mergedTypes = new Map();
+    for (const typeHandler of lhs.types || []) {
+        mergedTypes.set(typeHandler.name, typeHandler);
+    }
+    for (const typeHandler of rhs.types || []) {
+        mergedTypes.set(typeHandler.name, typeHandler);
+    }
+    return {
+        name: rhs.name,
+        runtimeSchemas: [
+            ...new Set([
+                ...(lhs.runtimeSchemas || []),
+                ...(rhs.runtimeSchemas || []),
+            ]),
+        ],
+        types: [...mergedTypes.values()],
+        validate: rhs.validate || lhs.validate,
+    };
+}
+function getRegisteredRuntimeHandlers() {
+    return [...runtimeHandlers.values()].sort((lhs, rhs) => lhs.name.localeCompare(rhs.name));
+}
+function registerExtensionRuntime(handler) {
+    const normalized = normalizeRuntimeHandler(handler);
+    const existing = runtimeHandlers.get(normalized.name);
+    runtimeHandlers.set(normalized.name, existing ? mergeRuntimeHandlers(existing, normalized) : normalized);
+}
+function clearExtensionRuntimes() {
+    runtimeHandlers.clear();
+    registeredTypeOIDs.clear();
+}
+function normalizeExtensions(extensions) {
+    return [...extensions]
+        .map((extension) => ({
+        ...extension,
+        provisionedBy: normalizeProvisionedBy(extension),
+        runtimeSchemas: extension.runtimeSchemas || [],
+        dropCascade: extension.dropCascade === true,
+    }))
+        .sort((lhs, rhs) => lhs.name.localeCompare(rhs.name));
+}
+function resolveExtensions(cfg) {
+    return normalizeExtensions(cfg || []);
+}
+function getExtensionSearchPathSchemas(extensions) {
+    const normalizedExtensions = normalizeExtensions(extensions);
+    const configuredExtensions = new Map(normalizedExtensions.map((extension) => [extension.name, extension]));
+    const seen = new Set();
+    const schemas = [];
+    function addSchemas(runtimeSchemas) {
+        for (const schema of runtimeSchemas) {
+            if (!schema || seen.has(schema)) {
+                continue;
+            }
+            seen.add(schema);
+            schemas.push(schema);
+        }
+    }
+    for (const extension of normalizedExtensions) {
+        addSchemas(extension.runtimeSchemas || []);
+    }
+    for (const handler of getRegisteredRuntimeHandlers()) {
+        const configured = configuredExtensions.get(handler.name);
+        addSchemas(configured
+            ? configured.runtimeSchemas || []
+            : handler.runtimeSchemas || []);
+    }
+    return schemas;
+}
+function buildExtensionSearchPath(resolvedDevSchema, extensions) {
+    const schemas = [];
+    if (resolvedDevSchema.enabled && resolvedDevSchema.schemaName) {
+        schemas.push(resolvedDevSchema.schemaName);
+    }
+    for (const schema of getExtensionSearchPathSchemas(extensions)) {
+        if (!schemas.includes(schema)) {
+            schemas.push(schema);
+        }
+    }
+    if (resolvedDevSchema.enabled &&
+        resolvedDevSchema.includePublic &&
+        !schemas.includes("public")) {
+        schemas.push("public");
+    }
+    if (!resolvedDevSchema.enabled &&
+        schemas.length > 0 &&
+        !schemas.includes("public")) {
+        schemas.push("public");
+    }
+    if (schemas.length === 0) {
+        return undefined;
+    }
+    return schemas.join(",");
+}
+async function getInstalledExtensions(pool, extensions) {
+    if (extensions.length === 0) {
+        return new Map();
+    }
+    const res = await pool.query(`
+      SELECT
+        extname,
+        extversion,
+        extnamespace::regnamespace::text AS install_schema
+      FROM pg_extension
+      WHERE extname = ANY($1::text[])
+    `, [extensions.map((extension) => extension.name)]);
+    const installed = new Map();
+    for (const row of res.rows) {
+        installed.set(row.extname, {
+            name: row.extname,
+            version: row.extversion,
+            installSchema: row.install_schema,
+        });
+    }
+    return installed;
+}
+function registerArrayParser(arrayOID, parse) {
+    if (!arrayOID || registeredTypeOIDs.has(arrayOID)) {
+        return;
+    }
+    const parseTextArray = pg_1.types.getTypeParser(TEXT_ARRAY_OID);
+    pg_1.types.setTypeParser(arrayOID, (value) => {
+        if (value === null) {
+            return null;
+        }
+        const parsed = parseTextArray(value);
+        return parsed.map((entry) => parse(entry));
+    });
+    registeredTypeOIDs.add(arrayOID);
+}
+async function initializeRegisteredTypeParsers(pool, configuredExtensions) {
+    const registeredTypes = new Map();
+    for (const handler of getRegisteredRuntimeHandlers()) {
+        for (const typeHandler of handler.types || []) {
+            registeredTypes.set(typeHandler.name, {
+                extensionName: handler.name,
+                parse: typeHandler.parse,
+            });
+        }
+    }
+    if (registeredTypes.size === 0) {
+        return;
+    }
+    const res = await pool.query(`
+      SELECT oid, typname, typarray
+      FROM pg_type
+      WHERE typname = ANY($1::text[])
+    `, [[...registeredTypes.keys()]]);
+    const rowsByType = new Map(res.rows.map((row) => [row.typname, row]));
+    for (const [typeName, typeHandler] of registeredTypes.entries()) {
+        const row = rowsByType.get(typeName);
+        if (!row) {
+            if (configuredExtensions.has(typeHandler.extensionName)) {
+                throw new Error(`required pg type "${typeName}" for db extension "${typeHandler.extensionName}" was not found`);
+            }
+            continue;
+        }
+        if (!registeredTypeOIDs.has(row.oid)) {
+            pg_1.types.setTypeParser(row.oid, typeHandler.parse);
+            registeredTypeOIDs.add(row.oid);
+        }
+        registerArrayParser(row.typarray, typeHandler.parse);
+    }
+}
+async function initializeExtensions(pool, extensions) {
+    const normalizedExtensions = normalizeExtensions(extensions);
+    const configuredExtensions = new Map(normalizedExtensions.map((extension) => [extension.name, extension]));
+    const installedExtensions = await getInstalledExtensions(pool, normalizedExtensions);
+    for (const extension of normalizedExtensions) {
+        const installed = installedExtensions.get(extension.name);
+        if (!installed) {
+            throw new Error(`required db extension "${extension.name}" is not installed`);
+        }
+        if (extension.version && extension.version !== installed.version) {
+            throw new Error(`required db extension "${extension.name}" version "${extension.version}" but found "${installed.version}"`);
+        }
+        if (extension.installSchema &&
+            extension.installSchema !== installed.installSchema) {
+            throw new Error(`required db extension "${extension.name}" install schema "${extension.installSchema}" but found "${installed.installSchema}"`);
+        }
+        const handler = runtimeHandlers.get(extension.name);
+        await handler?.validate?.(installed, extension);
+    }
+    await initializeRegisteredTypeParsers(pool, configuredExtensions);
+}

package/core/loaders/assoc_count_loader.js

@@ -32,23 +32,20 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssocEdgeCountLoaderFactory = exports.AssocEdgeCountLoader = void 0;
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const loader_1 = require("./loader");
 const raw_count_loader_1 = require("./raw_count_loader");
-const memoizee_1 = __importDefault(require("memoizee"));
+const memoize_1 = require("../memoize");
 class AssocEdgeCountLoader {
     constructor(edgeType, context, options) {
         this.edgeType = edgeType;
         this.context = context;
         this.options = options;
         if (context) {
-            this.loaderFn = (0, memoizee_1.default)(this.getLoader);
+            this.loaderFn = (0, memoize_1.memoizeNoArgs)(this.getLoader.bind(this));
         }
     }
     async getLoader() {