@snowtop/ent 0.2.6 → 0.2.8

package/core/db.js

@@ -39,6 +39,8 @@ const js_yaml_1 = require("js-yaml");
 const luxon_1 = require("luxon");
 const pg_1 = __importStar(require("pg"));
 const logger_1 = require("./logger");
+const dev_schema_1 = require("./dev_schema");
+const extensions_1 = require("./extensions");
 function isDbDict(v) {
     return (v["production"] !== undefined ||
         v["development"] !== undefined ||
@@ -76,15 +78,22 @@ function parseConnectionString(str, args) {
 // database file in yml file
 // database/config.yml
 function getClientConfig(args) {
+    const extensions = (0, extensions_1.resolveExtensions)(args?.extensions);
     // if there's a db connection string, use that first
     const str = process.env.DB_CONNECTION_STRING;
     if (str) {
-        return parseConnectionString(str, args);
+        const info = parseConnectionString(str, args);
+        info.devSchema = args?.devSchema;
+        info.extensions = extensions;
+        return info;
     }
     let file = "config/database.yml";
     if (args) {
         if (args.connectionString) {
-            return parseConnectionString(args.connectionString, args);
+            const info = parseConnectionString(args.connectionString, args);
+            info.devSchema = args?.devSchema;
+            info.extensions = extensions;
+            return info;
         }
         if (args.db) {
             let db;
@@ -100,6 +109,8 @@ function getClientConfig(args) {
             return {
                 dialect: Dialect.Postgres,
                 config: db,
+                devSchema: args?.devSchema,
+                extensions,
             };
         }
         if (args.dbFile) {
@@ -128,6 +139,8 @@ function getClientConfig(args) {
                     // max, min, etc
                     ...cfg,
                 },
+                devSchema: args?.devSchema,
+                extensions,
             };
         }
         throw new Error(`invalid yaml configuration in file`);
@@ -140,9 +153,39 @@ function getClientConfig(args) {
 class DB {
     constructor(db) {
         this.db = db;
+        const devSchemaEnabled = (0, dev_schema_1.isDevSchemaEnabled)(db.devSchema);
+        if (devSchemaEnabled && db.dialect === Dialect.SQLite) {
+            throw new Error("dev branch schemas are only supported for postgres");
+        }
+        const resolvedDevSchema = devSchemaEnabled
+            ? (0, dev_schema_1.resolveDevSchema)(db.devSchema)
+            : { enabled: false };
+        const extensions = db.extensions || [];
         if (db.dialect === Dialect.Postgres) {
+            const searchPath = (0, extensions_1.buildExtensionSearchPath)(resolvedDevSchema, extensions);
+            if (searchPath) {
+                const option = `-c search_path=${searchPath}`;
+                db.config = {
+                    ...db.config,
+                    options: db.config.options
+                        ? `${db.config.options} ${option}`
+                        : option,
+                };
+            }
             this.pool = new pg_1.Pool(db.config);
-            this.q = new Postgres(this.pool);
+            const schemaName = resolvedDevSchema.schemaName;
+            const readyTasks = [];
+            if (resolvedDevSchema.enabled && schemaName) {
+                readyTasks.push(validateDevSchema(this.pool, schemaName).then(() => touchDevSchemaRegistry(this.pool, schemaName, resolvedDevSchema.branchName).catch(() => { })));
+            }
+            readyTasks.push((0, extensions_1.initializeExtensions)(this.pool, extensions));
+            const ready = readyTasks.length > 0
+                ? Promise.all(readyTasks).then(() => undefined)
+                : undefined;
+            if (ready) {
+                ready.catch(() => { });
+            }
+            this.q = new Postgres(this.pool, ready);
             this.pool.on("error", (err, client) => {
                 (0, logger_1.log)("error", err);
             });
@@ -203,6 +246,10 @@ class DB {
     static initDB(args) {
         const config = getClientConfig(args);
         if (config) {
+            const existing = DB.instance;
+            if (existing) {
+                void existing.endPool().catch(() => { });
+            }
             DB.instance = new DB(config);
             DB.dialect = DB.instance.db.dialect;
         }
@@ -320,29 +367,39 @@ class Sqlite {
 }
 exports.Sqlite = Sqlite;
 class Postgres {
-    constructor(pool) {
+    constructor(pool, ready) {
         this.pool = pool;
+        this.ready = ready;
+    }
+    async ensureReady() {
+        if (this.ready) {
+            await this.ready;
+        }
     }
     self() {
         return this;
     }
     // returns new Pool client
     async newClient() {
+        await this.ensureReady();
         const client = await this.pool.connect();
         if (!client) {
             throw new Error(`couldn't get new client`);
         }
-        return new PostgresClient(client);
+        return new PostgresClient(client, this.ready);
     }
     async query(query, values) {
+        await this.ensureReady();
         const r = await this.pool.query(query, values);
         return r;
     }
     async queryAll(query, values) {
+        await this.ensureReady();
         const r = await this.pool.query(query, values);
         return r;
     }
     async exec(query, values) {
+        await this.ensureReady();
         const r = await this.pool.query(query, values);
         return {
             rowCount: r?.rowCount || 0,
@@ -350,23 +407,35 @@ class Postgres {
         };
     }
     async close() {
-        return this.pool.end();
+        if (!this.closePromise) {
+            this.closePromise = this.pool.end();
+        }
+        return this.closePromise;
     }
 }
 exports.Postgres = Postgres;
 class PostgresClient {
-    constructor(client) {
+    constructor(client, ready) {
         this.client = client;
+        this.ready = ready;
+    }
+    async ensureReady() {
+        if (this.ready) {
+            await this.ready;
+        }
     }
     async query(query, values) {
+        await this.ensureReady();
         const r = await this.client.query(query, values);
         return r;
     }
     async queryAll(query, values) {
+        await this.ensureReady();
         const r = await this.client.query(query, values);
         return r;
     }
     async exec(query, values) {
+        await this.ensureReady();
         const r = await this.client.query(query, values);
         return {
             rowCount: r?.rowCount || 0,
@@ -378,3 +447,29 @@ class PostgresClient {
     }
 }
 exports.PostgresClient = PostgresClient;
+async function validateDevSchema(pool, schemaName) {
+    const res = await pool.query("SELECT EXISTS (SELECT 1 FROM pg_namespace WHERE nspname = $1) AS ok", [schemaName]);
+    if (!res.rows?.[0]?.ok) {
+        throw new Error(`dev branch schema \"${schemaName}\" does not exist. Run auto_schema or migrations to create it.`);
+    }
+}
+async function touchDevSchemaRegistry(pool, schemaName, branchName) {
+    const branch = branchName ?? null;
+    try {
+        // Avoid DDL at runtime; registry table should be created by auto_schema/prune.
+        await pool.query(`
+      INSERT INTO public.ent_dev_schema_registry (schema_name, branch_name, created_at, last_used_at)
+      VALUES ($1, $2, now(), now())
+      ON CONFLICT (schema_name)
+      DO UPDATE SET last_used_at = now(), branch_name = EXCLUDED.branch_name
+      `, [schemaName, branch]);
+    }
+    catch (err) {
+        if (err &&
+            typeof err.message === "string" &&
+            err.message.includes("ent_dev_schema_registry")) {
+            return;
+        }
+        (0, logger_1.log)("debug", err);
+    }
+}

package/core/dev_schema.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeDevSchemaConfig } from "./config";
+export interface ResolvedDevSchema {
+    enabled: boolean;
+    schemaName?: string;
+    branchName?: string;
+    includePublic?: boolean;
+}
+export declare function resolveDevSchema(cfg?: RuntimeDevSchemaConfig): ResolvedDevSchema;
+export declare function isDevSchemaEnabled(cfg?: RuntimeDevSchemaConfig): boolean;

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,7 +1,7 @@
-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 DataLoader from "dataloader";
 import * as clause from "./clause";
+import { InstrumentedDataLoader } from "./loaders/loader";
 import { OrderBy } from "./query_impl";
 declare class entCacheMap<TViewer extends Viewer, TEnt extends Ent<TViewer>> {
     private viewer;
@@ -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;
@@ -160,7 +158,7 @@ export declare class AssocEdgeData {
     edgeTable: string;
     constructor(data: Data);
 }
-export declare const assocEdgeLoader: DataLoader<ID, Data | null, ID>;
+export declare const assocEdgeLoader: InstrumentedDataLoader<ID, Data | null>;
 export declare function loadEdgeData(edgeType: string): Promise<AssocEdgeData | null>;
 export declare function loadEdgeDatas(...edgeTypes: string[]): Promise<Map<string, AssocEdgeData>>;
 export interface AssocEdgeConstructor<T extends AssocEdge> {