@snowtop/ent 0.2.7 → 0.2.8

package/action/executor.js

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComplexExecutor = exports.ListBasedExecutor = void 0;
 exports.executeOperations = executeOperations;
-const graph_data_structure_1 = require("graph-data-structure");
 const ent_1 = require("../core/ent");
 const db_1 = __importDefault(require("../core/db"));
 const logger_1 = require("../core/logger");
+const topological_sort_1 = require("./topological_sort");
 const operations_1 = require("./operations");
 // private to ent
 class ListBasedExecutor {
@@ -123,7 +123,7 @@ class ComplexExecutor {
         this.executors = [];
         this.changedOps = new Map();
         this.builder = options?.builder;
-        const graph = new graph_data_structure_1.Graph();
+        const graph = new topological_sort_1.TopologicalGraph();
         const changesetMap = new Map();
         const impl = (c) => {
             changesetMap.set(c.placeholderID.toString(), c);
@@ -131,7 +131,7 @@ class ComplexExecutor {
             if (c.dependencies) {
                 for (let [_, builder] of c.dependencies) {
                     // dependency should go first...
-                    graph.addEdge(builder.placeholderID.toString(), c.placeholderID.toString(), 1);
+                    graph.addEdge(builder.placeholderID.toString(), c.placeholderID.toString());
                 }
             }
             if (c.changesets) {
@@ -156,7 +156,7 @@ class ComplexExecutor {
         // TODO: can this logic be rewritten to not have a set yet avoid duplicates?
         let nodeOps = new Set();
         let remainOps = new Set();
-        const sorted = (0, graph_data_structure_1.topologicalSort)(graph);
+        const sorted = graph.topologicalSort();
         sorted.forEach((node) => {
             let c = changesetMap.get(node);
             if (!c) {

package/action/operations.js

@@ -237,6 +237,9 @@ class EditNodeOperation {
             return `RETURNING ${this.options.loadEntOptions.fields
                 .map((f) => {
                 if (typeof f === "object") {
+                    if ("expression" in f) {
+                        throw new Error("RETURNING does not support computed select expressions");
+                    }
                     return `${f.alias}.${f.column}`;
                 }
                 return f;

package/action/orchestrator.js

@@ -32,9 +32,6 @@ 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.EntChangeset = exports.Orchestrator = exports.edgeDirection = void 0;
 const ent_1 = require("../core/ent");
@@ -43,8 +40,8 @@ const operations_1 = require("./operations");
 const action_1 = require("../action");
 const privacy_1 = require("../core/privacy");
 const executor_1 = require("./executor");
+const memoize_1 = require("../core/memoize");
 const logger_1 = require("../core/logger");
-const memoizee_1 = __importDefault(require("memoizee"));
 const clause = __importStar(require("../core/clause"));
 const types_1 = require("util/types");
 const operations_2 = require("./operations");
@@ -112,7 +109,7 @@ class Orchestrator {
         this.viewer = options.viewer;
         this.actualOperation = this.options.operation;
         this.existingEnt = this.options.builder.existingEnt;
-        this.memoizedGetFields = (0, memoizee_1.default)(this.getFieldsInfo.bind(this));
+        this.memoizedGetFields = (0, memoize_1.memoizeNoArgs)(this.getFieldsInfo.bind(this));
     }
     // don't type this because we don't care
     __getOptions() {
@@ -639,19 +636,20 @@ class Orchestrator {
                 for (const [k, field] of schemaFields) {
                     const inputKey = this.getInputKey(k);
                     const storageKey = this.getStorageKey(k);
-                    let val = transformed.data[inputKey];
-                    if (val === undefined) {
-                        val = transformed.data[storageKey];
+                    let inputVal = transformed.data[inputKey];
+                    if (inputVal === undefined) {
+                        inputVal = transformed.data[storageKey];
                     }
-                    if (val === undefined) {
+                    if (inputVal === undefined) {
                         continue;
                     }
+                    let dbVal = inputVal;
                     if (field.format) {
-                        val = field.format(transformed.data[k], true);
+                        dbVal = field.format(inputVal, true);
                     }
-                    data[this.getStorageKey(k)] = val;
+                    data[this.getStorageKey(k)] = dbVal;
                     if (!field.immutable) {
-                        this.defaultFieldsByTSName[this.getInputKey(k)] = val;
+                        this.defaultFieldsByTSName[this.getInputKey(k)] = inputVal;
                     }
                     // hmm do we need this?
                     // TODO how to do this for local tests?

package/action/topological_sort.d.ts

@@ -0,0 +1,9 @@
+type NodeID = string;
+export declare class TopologicalGraph {
+    private nodes;
+    private edges;
+    addNode(node: NodeID): void;
+    addEdge(from: NodeID, to: NodeID): void;
+    topologicalSort(): NodeID[];
+}
+export {};

package/action/topological_sort.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologicalGraph = void 0;
+class TopologicalGraph {
+    constructor() {
+        this.nodes = new Set();
+        this.edges = new Map();
+    }
+    addNode(node) {
+        this.nodes.add(node);
+        if (!this.edges.has(node)) {
+            this.edges.set(node, new Set());
+        }
+    }
+    addEdge(from, to) {
+        this.addNode(from);
+        this.addNode(to);
+        this.edges.get(from).add(to);
+    }
+    topologicalSort() {
+        const ordered = [];
+        const seen = new Map();
+        const visit = (node) => {
+            const state = seen.get(node);
+            if (state === 1) {
+                throw new Error("Cycle found");
+            }
+            if (state === 2) {
+                return;
+            }
+            seen.set(node, 1);
+            for (const target of this.edges.get(node) || []) {
+                visit(target);
+            }
+            seen.set(node, 2);
+            ordered.push(node);
+        };
+        for (const node of this.nodes) {
+            if (seen.get(node) !== 2) {
+                visit(node);
+            }
+        }
+        return ordered.reverse();
+    }
+}
+exports.TopologicalGraph = TopologicalGraph;

package/core/base.d.ts

@@ -1,6 +1,7 @@
 import * as clause from "./clause";
 import { ObjectLoaderFactory } from "./loaders";
 import { OrderBy } from "./query_impl";
+import { QueryExpression } from "./query_expression";
 export interface Loader<K, V> {
     context?: Context;
     load(key: K): Promise<V>;
@@ -61,16 +62,22 @@ export interface EntConstructor<TEnt extends Ent, TViewer extends Viewer = Viewe
     new (viewer: TViewer, data: Data): TEnt;
 }
 export type ID = string | number;
+export interface SelectColumnField {
+    alias: string;
+    column: string;
+}
+export interface SelectExpressionField {
+    alias: string;
+    expression: QueryExpression;
+}
+export type SelectField = string | SelectColumnField | SelectExpressionField;
 export interface DataOptions {
     tableName: string;
     alias?: string;
     context?: Context;
 }
 export interface SelectBaseDataOptions extends DataOptions {
-    fields: (string | {
-        alias: string;
-        column: string;
-    })[];
+    fields: SelectField[];
     fieldsAlias?: string;
     disableFieldsAlias?: boolean;
     disableDefaultOrderByAlias?: boolean;

package/core/clause.d.ts

@@ -1,10 +1,7 @@
 import { Data, ID, SelectDataOptions } from "./base";
-export interface Clause<T extends Data = Data, K = keyof T> {
-    clause(idx: number, alias?: string): string;
+import { QueryExpression } from "./query_expression";
+export interface Clause<T extends Data = Data, K = keyof T> extends QueryExpression {
     columns(): K[];
-    values(): any[];
-    instanceKey(): string;
-    logValues(): any[];
     compositeOp?: string;
 }
 export interface SensitiveValue {
@@ -180,4 +177,5 @@ export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any,
 export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K>, checkIntersection?: boolean): Clause<V, K>;
 export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Pick<SelectDataOptions, "clause">, cls: Clause<V, K> | undefined, checkIntersection?: boolean): Clause<V, K> | undefined;
 export declare function Expression<T extends Data, K = keyof T>(expression: string): Clause<T, K>;
+export declare function ParameterizedExpression(key: string, expression: (idx: number, alias?: string) => string, values: any[], logValues?: any[]): QueryExpression;
 export {};

package/core/clause.js

@@ -92,6 +92,7 @@ exports.Divide = Divide;
 exports.Modulo = Modulo;
 exports.getCombinedClause = getCombinedClause;
 exports.Expression = Expression;
+exports.ParameterizedExpression = ParameterizedExpression;
 const db_1 = __importStar(require("./db"));
 const query_impl_1 = require("./query_impl");
 function isSensitive(val) {
@@ -256,6 +257,34 @@ class simpleExpression {
         return `${this.expression}`;
     }
 }
+class parameterizedExpression {
+    constructor(key, expression, params, logParams) {
+        this.key = key;
+        this.expression = expression;
+        this.params = params;
+        this.logParams = logParams;
+    }
+    clause(idx, alias) {
+        return this.expression(idx, alias);
+    }
+    values() {
+        return this.params.map((value) => rawValue(value));
+    }
+    logValues() {
+        if (this.logParams) {
+            return this.logParams;
+        }
+        return this.params.map((value) => {
+            if (isSensitive(value)) {
+                return value.logValue();
+            }
+            return value;
+        });
+    }
+    instanceKey() {
+        return this.key;
+    }
+}
 class arraySimpleClause {
     constructor(col, value, op, overrideAlias) {
         this.col = col;
@@ -1107,3 +1136,6 @@ function getCombinedClause(options, cls, checkIntersection = false) {
 function Expression(expression) {
     return new simpleExpression(expression);
 }
+function ParameterizedExpression(key, expression, values, logValues) {
+    return new parameterizedExpression(key, expression, values, logValues);
+}

package/core/config.d.ts

@@ -12,6 +12,14 @@ declare enum fieldPrivacyEvaluated {
     AT_ENT_LOAD = "at_ent_load",
     ON_DEMAND = "on_demand"
 }
+export interface RuntimeDBExtension {
+    name: string;
+    provisionedBy?: "ent" | "external";
+    version?: string;
+    installSchema?: string;
+    runtimeSchemas?: string[];
+    dropCascade?: boolean;
+}
 export interface Config {
     dbConnectionString?: string;
     dbFile?: string;
@@ -22,18 +30,34 @@ export interface Config {
     loaderMaxBatchSize?: number;
     clauseLoaderConcurrency?: number;
     entLoaderPrivacyConcurrencyLimit?: number;
+    devSchema?: RuntimeDevSchemaConfig;
+    extensions?: RuntimeDBExtension[];
 }
-export interface ConfigWithCodegen extends Config {
+export interface ConfigWithCodegen extends Omit<Config, "devSchema"> {
     codegen?: CodegenConfig;
     databaseMigration?: DatabaseMigrationConfig;
     customGraphQLJSONPath?: string;
     dynamicScriptCustomGraphQLJSONPath?: string;
     globalSchemaPath?: string;
+    devSchema?: DevSchemaConfig;
 }
 interface DatabaseMigrationConfig {
     custom_sql_include?: string[];
     custom_sql_exclude?: string[];
 }
+export interface DevSchemaPruneConfig {
+    enabled?: boolean;
+    days?: number;
+}
+export interface RuntimeDevSchemaConfig {
+    enabled?: boolean;
+    schemaName?: string;
+    includePublic?: boolean;
+    ignoreBranches?: string[];
+}
+export interface DevSchemaConfig extends RuntimeDevSchemaConfig {
+    prune?: DevSchemaPruneConfig;
+}
 interface CodegenConfig {
     defaultEntPolicy?: PrivacyConfig;
     defaultActionPolicy?: PrivacyConfig;
@@ -70,5 +94,5 @@ interface importedObject {
     name: string;
     alias?: string;
 }
-export declare function loadConfig(file?: string | Buffer | Config): void;
+export declare function loadConfig(file?: string | Buffer | Config | ConfigWithCodegen): void;
 export {};

package/core/config.js

@@ -66,11 +66,17 @@ function setConfig(cfg) {
     if (cfg.log) {
         (0, logger_1.setLogLevels)(cfg.log);
     }
-    if (cfg.dbConnectionString || cfg.dbFile || cfg.db) {
+    if (cfg.dbConnectionString ||
+        cfg.dbFile ||
+        cfg.db ||
+        cfg.devSchema ||
+        cfg.extensions) {
         db_1.default.initDB({
             connectionString: cfg.dbConnectionString,
             dbFile: cfg.dbFile,
             db: cfg.db,
+            devSchema: cfg.devSchema,
+            extensions: cfg.extensions,
         });
     }
     (0, ent_1.___setLogQueryErrorWithError)(cfg.logQueryWithError);

package/core/context.js

@@ -7,6 +7,7 @@ exports.getContextCacheKey = getContextCacheKey;
 const logger_1 = require("./logger");
 const cache_utils_1 = require("./cache_utils");
 const metrics_1 = require("./metrics");
+const query_impl_1 = require("./query_impl");
 const DEFAULT_MAX_DISCARDED_LOADERS = 1000;
 let maxDiscardedLoaders = DEFAULT_MAX_DISCARDED_LOADERS;
 function getContextCacheMaxDiscardedLoaders() {
@@ -23,16 +24,8 @@ function setContextCacheMaxDiscardedLoaders(size) {
     maxDiscardedLoaders = Math.floor(size);
 }
 function getContextCacheKey(options) {
-    const fields = options.fields
-        .map((f) => {
-        if (typeof f === "object") {
-            return `${f.alias}.${f.column}`;
-        }
-        return f;
-    })
-        .join(",");
     const parts = [
-        `fields:${fields}`,
+        `fields:${(0, query_impl_1.getSelectFieldsKey)(options.fields)}`,
         `clause:${options.clause.instanceKey()}`,
     ];
     if (options.distinct !== undefined) {
@@ -54,7 +47,7 @@ function getContextCacheKey(options) {
         parts.push(`groupby:${options.groupby}`);
     }
     if (options.orderby) {
-        parts.push(`orderby:${(0, cache_utils_1.stableStringify)(options.orderby)}`);
+        parts.push(`orderby:${(0, query_impl_1.getOrderByKey)(options.orderby)}`);
     }
     if (options.join) {
         const joinKey = options.join.map((join) => ({
@@ -124,7 +117,7 @@ class ContextCache {
             }
             (0, logger_1.log)("cache", {
                 "cache-hit": key,
-                "tableName": options.tableName,
+                tableName: options.tableName,
             });
         }
         return rows || null;
@@ -146,7 +139,7 @@ class ContextCache {
             }
             (0, logger_1.log)("cache", {
                 "cache-hit": key,
-                "tableName": options.tableName,
+                tableName: options.tableName,
             });
         }
         return row || null;

package/core/db.d.ts

@@ -1,4 +1,5 @@
 import { Pool, PoolClient, PoolConfig } from "pg";
+import type { RuntimeDBExtension, RuntimeDevSchemaConfig } from "./config";
 export interface Database extends PoolConfig {
     database?: string;
     user?: string;
@@ -17,12 +18,16 @@ interface DatabaseInfo {
     dialect: Dialect;
     config: PoolConfig;
     filePath?: string;
+    devSchema?: RuntimeDevSchemaConfig;
+    extensions?: RuntimeDBExtension[];
 }
 interface clientConfigArgs {
     connectionString?: string;
     dbFile?: string;
     db?: Database | DBDict;
     cfg?: PoolConfig;
+    devSchema?: RuntimeDevSchemaConfig;
+    extensions?: RuntimeDBExtension[];
 }
 export default class DB {
     db: DatabaseInfo;
@@ -112,7 +117,10 @@ export declare class Sqlite implements Connection, SyncClient {
 }
 export declare class Postgres implements Connection {
     private pool;
-    constructor(pool: Pool);
+    private ready?;
+    private closePromise?;
+    constructor(pool: Pool, ready?: Promise<void> | undefined);
+    private ensureReady;
     self(): this;
     newClient(): Promise<PostgresClient>;
     query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
@@ -122,7 +130,9 @@ export declare class Postgres implements Connection {
 }
 export declare class PostgresClient implements Client {
     private client;
-    constructor(client: PoolClient);
+    private ready?;
+    constructor(client: PoolClient, ready?: Promise<void> | undefined);
+    private ensureReady;
     query(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
     queryAll(query: string, values?: any[]): Promise<QueryResult<QueryResultRow>>;
     exec(query: string, values?: any[]): Promise<ExecResult>;

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;