@snowtop/ent 0.1.0-alpha126 → 0.1.0-alpha128

package/core/base.d.ts

@@ -1,4 +1,5 @@
 import * as clause from "./clause";
+import { ObjectLoaderFactory } from "./loaders";
 export interface Loader<K, V> {
     context?: Context;
     load(key: K): Promise<V>;
@@ -95,21 +96,21 @@ export interface EditRowOptions extends CreateRowOptions {
     whereClause: clause.Clause;
     expressions?: Map<string, clause.Clause>;
 }
-interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> {
-    loaderFactory: LoaderFactoryWithOptions;
+interface LoadableEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> {
+    loaderFactory: ObjectLoaderFactory<TData>;
     ent: EntConstructor<TEnt, TViewer>;
 }
-export interface LoaderFactoryWithOptions extends LoaderFactoryWithLoaderMany<any, Data | null> {
+export interface LoaderFactoryWithOptions<T extends Data = Data> extends LoaderFactoryWithLoaderMany<any, T | null> {
     options?: SelectDataOptions;
 }
-export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends LoadableEntOptions<TEnt, TViewer>, SelectBaseDataOptions {
+export interface LoadEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends LoadableEntOptions<TEnt, TViewer, TData>, SelectBaseDataOptions {
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface SelectCustomDataOptions extends SelectBaseDataOptions {
-    loaderFactory: LoaderFactoryWithOptions;
+export interface SelectCustomDataOptions<T extends Data = Data> extends SelectBaseDataOptions {
+    loaderFactory: ObjectLoaderFactory<T>;
     prime?: boolean;
 }
-export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer> extends SelectCustomDataOptions {
+export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer = Viewer, TData extends Data = Data> extends SelectCustomDataOptions<TData> {
     ent: EntConstructor<TEnt, TViewer>;
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }

package/core/clause.d.ts

@@ -1,4 +1,4 @@
-import { Data } from "./base";
+import { Data, SelectDataOptions } from "./base";
 export interface Clause<T extends Data = Data, K = keyof T> {
     clause(idx: number): string;
     columns(): K[];
@@ -102,4 +102,5 @@ export declare function Subtract<T extends Data, K = keyof T>(col: K, value: any
 export declare function Multiply<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Divide<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
 export declare function Modulo<T extends Data, K = keyof T>(col: K, value: any): Clause<T, K>;
+export declare function getCombinedClause<V extends Data = Data, K = keyof V>(options: Omit<SelectDataOptions, "key">, cls: Clause<V, K>): Clause<V, K>;
 export {};

package/core/clause.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
+exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -731,3 +731,20 @@ function Modulo(col, value) {
     return new simpleClause(col, value, "%", new isNullClause(col));
 }
 exports.Modulo = Modulo;
+function getCombinedClause(options, cls) {
+    if (options.clause) {
+        let optionClause;
+        if (typeof options.clause === "function") {
+            optionClause = options.clause();
+        }
+        else {
+            optionClause = options.clause;
+        }
+        if (optionClause) {
+            // @ts-expect-error different types
+            cls = And(cls, optionClause);
+        }
+    }
+    return cls;
+}
+exports.getCombinedClause = getCombinedClause;

package/core/ent.d.ts

@@ -4,7 +4,6 @@ import { Executor } from "../action/action";
 import * as clause from "./clause";
 import { Builder } from "../action";
 import DataLoader from "dataloader";
-import { GlobalSchema } from "../schema/";
 export declare function getEntKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): string;
 export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
@@ -24,13 +23,13 @@ export declare function loadEntsList<TEnt extends Ent<TViewer>, TViewer extends
  * @deperecated use loadCustomEnts
  */
 export declare function loadEntsFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, clause: clause.Clause, options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
-export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer, TQueryData extends Data = Data, TResultData extends Data = TQueryData, TKey = keyof TQueryData>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer>, query: CustomQuery<TQueryData, TKey>): Promise<TEnt[]>;
+export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer, TQueryData extends Data = Data, TResultData extends Data = TQueryData, TKey = keyof TQueryData>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer, TResultData>, query: CustomQuery<TQueryData, TKey>): Promise<TEnt[]>;
 interface parameterizedQueryOptions {
     query: string;
     values?: any[];
     logValues?: any[];
 }
-export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameterizedQueryOptions | clause.Clause<T, K> | QueryDataOptions;
+export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameterizedQueryOptions | clause.Clause<T, K> | QueryDataOptions<T, K>;
 /**
  * Note that if there's default read transformations (e.g. soft delete) and a clause is passed in
  * either as Clause or QueryDataOptions without {disableTransformations: true}, the default transformation
@@ -54,11 +53,15 @@ export type CustomQuery<T extends Data = Data, K = keyof T> = string | parameter
  *   orderby: 'time',
  *   disableTransformations: false
  *  }) // doesn't change the query
+ *
+ * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
+ * or parallel queries with the same clause are batched together.
+ *
+ * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
+ * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
  */
-export declare function loadCustomData<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData>(options: SelectCustomDataOptions, query: CustomQuery<TQueryData, K>, context: Context | undefined): Promise<TResultData[]>;
-interface CustomCountOptions extends DataOptions {
-}
-export declare function loadCustomCount<T extends Data = Data, K = keyof T>(options: CustomCountOptions, query: CustomQuery<T, K>, context: Context | undefined): Promise<number>;
+export declare function loadCustomData<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData>(options: SelectCustomDataOptions<TResultData>, query: CustomQuery<TQueryData, K>, context: Context | undefined): Promise<TResultData[]>;
+export declare function loadCustomCount<T extends Data = Data, K = keyof T>(options: SelectCustomDataOptions<T>, query: CustomQuery<T, K>, context: Context | undefined): Promise<number>;
 export declare function loadDerivedEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt | null>;
 export declare function loadDerivedEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt>;
 export declare function logQuery(query: string, logValues: any[]): void;
@@ -114,9 +117,6 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     returnedRow(): Data | null;
     createdEnt(viewer: Viewer): T | null;
 }
-export declare function setGlobalSchema(val: GlobalSchema): void;
-export declare function clearGlobalSchema(): void;
-export declare function __hasGlobalSchema(): boolean;
 export declare class EdgeOperation implements DataOperation {
     private builder;
     edgeInput: AssocEdgeInput;

package/core/ent.js

@@ -26,15 +26,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = exports.EditNodeOperation = exports.RawQueryOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
-exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = void 0;
+exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadCustomEdges = exports.getEdgeClauseAndFields = exports.loadEdges = exports.DefaultLimit = exports.loadEdgeDatas = exports.loadEdgeData = exports.assocEdgeLoader = exports.AssocEdgeData = exports.getCursor = exports.AssocEdge = exports.DeleteNodeOperation = exports.deleteRowsSync = exports.deleteRows = exports.editRowSync = exports.editRow = exports.buildUpdateQuery = exports.createRowSync = exports.createRow = exports.buildInsertQuery = exports.EdgeOperation = exports.EditNodeOperation = exports.RawQueryOperation = exports.buildGroupQuery = exports.buildQuery = exports.loadRows = exports.performRawQuery = exports.___setLogQueryErrorWithError = exports.loadRow = exports.loadRowX = exports.logQuery = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadCustomCount = exports.loadCustomData = exports.loadCustomEnts = exports.loadEntsFromClause = exports.loadEntsList = exports.loadEnts = exports.loadEntXFromClause = exports.loadEntFromClause = exports.loadEntXViaKey = exports.loadEntX = exports.loadEntViaKey = exports.loadEnt = exports.getEntKey = void 0;
+exports.getEdgeTypeInGroup = exports.applyPrivacyPolicyForRows = exports.applyPrivacyPolicyForRow = void 0;
 const db_1 = __importStar(require("./db"));
 const privacy_1 = require("./privacy");
 const clause = __importStar(require("./clause"));
 const action_1 = require("../action");
 const logger_1 = require("./logger");
 const dataloader_1 = __importDefault(require("dataloader"));
-const schema_1 = require("../schema/");
+const schema_1 = require("../schema/schema");
+const global_schema_1 = require("./global_schema");
 // TODO kill this and createDataLoader
 class cacheMap {
     constructor(options) {
@@ -396,6 +397,12 @@ function isParameterizedQuery(opts) {
  *   orderby: 'time',
  *   disableTransformations: false
  *  }) // doesn't change the query
+ *
+ * For queries that pass in a clause, we batch them with an underlying dataloader so that multiple queries with the same clause
+ * or parallel queries with the same clause are batched together.
+ *
+ * If a raw or parameterized query is passed in, we don't attempt to batch them together and they're executed as is.
+ * If you end up with a scenario where you may need to coalesce or batch (non-clause) queries here, you should use some kind of memoization here.
  */
 async function loadCustomData(options, query, context) {
     const rows = await loadCustomDataImpl(options, query, context);
@@ -414,7 +421,10 @@ exports.loadCustomData = loadCustomData;
 // NOTE: if you use a raw query or paramterized query with this,
 // you should use `SELECT count(*) as count...`
 async function loadCustomCount(options, query, context) {
-    // TODO also need to loaderify this in case we're querying for this a lot...
+    // if clause, we'll use the loader and strong typing/coalescing it provides
+    if (typeof query !== "string" && isClause(query)) {
+        return options.loaderFactory.createCountLoader(context).load(query);
+    }
     const rows = await loadCustomDataImpl({
         ...options,
         fields: ["count(1) as count"],
@@ -429,50 +439,31 @@ function isPrimableLoader(loader) {
     return loader != undefined;
 }
 async function loadCustomDataImpl(options, query, context) {
-    function getClause(cls) {
-        let optClause = options.loaderFactory?.options?.clause;
-        if (typeof optClause === "function") {
-            optClause = optClause();
-        }
-        if (!optClause) {
-            return cls;
-        }
-        // @ts-expect-error string|ID mismatch
-        return clause.And(cls, optClause);
-    }
     if (typeof query === "string") {
         // no caching, perform raw query
         return performRawQuery(query, [], []);
-        // @ts-ignore
     }
     else if (isClause(query)) {
-        // if a Clause is passed in and we have a default clause
-        // associated with the query, pass that in
-        // if we want to disableTransformations, need to indicate that with
-        // disableTransformations option
-        // this will have rudimentary caching but nothing crazy
-        return loadRows({
-            ...options,
-            // @ts-ignore
-            clause: getClause(query),
-            context: context,
-        });
+        const r = await options.loaderFactory
+            .createTypedLoader(context)
+            .load(query);
+        return r;
     }
     else if (isParameterizedQuery(query)) {
         // no caching, perform raw query
         return performRawQuery(query.query, query.values || [], query.logValues);
     }
     else {
+        // this will have rudimentary caching but nothing crazy
         let cls = query.clause;
         if (!query.disableTransformations) {
-            // @ts-ignore
-            cls = getClause(cls);
+            cls = clause.getCombinedClause(options.loaderFactory.options, query.clause);
         }
-        // this will have rudimentary caching but nothing crazy
         return loadRows({
             ...query,
             ...options,
             context: context,
+            // @ts-expect-error
             clause: cls,
         });
     }
@@ -609,7 +600,7 @@ async function performRawQuery(query, values, logValues) {
     catch (e) {
         if (_logQueryWithError) {
             const msg = e.message;
-            throw new Error(`error \`${msg}\` running query: \`${query}\``);
+            throw new Error(`error \`${msg}\` running query: \`${query}\` with values: \`${logValues}\``);
         }
         throw e;
     }
@@ -816,20 +807,6 @@ class EditNodeOperation {
     }
 }
 exports.EditNodeOperation = EditNodeOperation;
-let globalSchema;
-function setGlobalSchema(val) {
-    globalSchema = val;
-}
-exports.setGlobalSchema = setGlobalSchema;
-function clearGlobalSchema() {
-    globalSchema = undefined;
-}
-exports.clearGlobalSchema = clearGlobalSchema;
-// used by tests. no guarantee will always exist
-function __hasGlobalSchema() {
-    return globalSchema !== undefined;
-}
-exports.__hasGlobalSchema = __hasGlobalSchema;
 class EdgeOperation {
     constructor(builder, edgeInput, options) {
         this.builder = builder;
@@ -872,8 +849,9 @@ class EdgeOperation {
         let op = schema_1.SQLStatementOperation.Delete;
         let updateData = null;
         // TODO respect disableTransformations
-        if (globalSchema?.transformEdgeWrite) {
-            transformed = globalSchema.transformEdgeWrite({
+        const transformedEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
+        if (transformedEdgeWrite) {
+            transformed = transformedEdgeWrite({
                 op: schema_1.SQLStatementOperation.Delete,
                 edge,
             });
@@ -951,9 +929,10 @@ class EdgeOperation {
             fields["time"] = new Date().toISOString();
         }
         const onConflictFields = ["data"];
-        if (globalSchema?.extraEdgeFields) {
-            for (const name in globalSchema.extraEdgeFields) {
-                const f = globalSchema.extraEdgeFields[name];
+        const extraEdgeFields = (0, global_schema_1.__getGlobalSchema)()?.extraEdgeFields;
+        if (extraEdgeFields) {
+            for (const name in extraEdgeFields) {
+                const f = extraEdgeFields[name];
                 if (f.defaultValueOnCreate) {
                     const storageKey = (0, schema_1.getStorageKey)(f, name);
                     fields[storageKey] = f.defaultValueOnCreate(this.builder, {});
@@ -965,8 +944,9 @@ class EdgeOperation {
         }
         // TODO respect disableTransformations
         let transformed = null;
-        if (globalSchema?.transformEdgeWrite) {
-            transformed = globalSchema.transformEdgeWrite({
+        const transformEdgeWrite = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeWrite;
+        if (transformEdgeWrite) {
+            transformed = transformEdgeWrite({
                 op: schema_1.SQLStatementOperation.Insert,
                 edge,
             });
@@ -1483,8 +1463,9 @@ async function loadEdges(options) {
 exports.loadEdges = loadEdges;
 function getEdgeClauseAndFields(cls, options) {
     let fields = edgeFields;
-    if (globalSchema?.transformEdgeRead) {
-        const transformClause = globalSchema.transformEdgeRead();
+    const transformEdgeRead = (0, global_schema_1.__getGlobalSchema)()?.transformEdgeRead;
+    if (transformEdgeRead) {
+        const transformClause = transformEdgeRead();
         if (!options.disableTransformations) {
             cls = clause.And(cls, transformClause);
         }

package/core/global_schema.d.ts

@@ -0,0 +1,7 @@
+import { Field, GlobalSchema } from "../schema/schema";
+export declare function setGlobalSchema(val: GlobalSchema): void;
+export declare function clearGlobalSchema(): void;
+export declare function __hasGlobalSchema(): boolean;
+export declare function __getGlobalSchema(): GlobalSchema | undefined;
+export declare function __getGlobalSchemaFields(): Map<string, Field>;
+export declare function __getGlobalSchemaField(type: string): Field | undefined;

package/core/global_schema.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__getGlobalSchemaField = exports.__getGlobalSchemaFields = exports.__getGlobalSchema = exports.__hasGlobalSchema = exports.clearGlobalSchema = exports.setGlobalSchema = void 0;
+const schema_1 = require("../schema/schema");
+let globalSchema;
+let globalSchemaFields = new Map();
+function isGlobalSchemaField(f) {
+    switch (f.type.dbType) {
+        case schema_1.DBType.Enum:
+        case schema_1.DBType.StringEnum:
+        case schema_1.DBType.IntEnum:
+        case schema_1.DBType.JSON:
+        case schema_1.DBType.JSONB:
+            return true;
+    }
+    return false;
+}
+function setGlobalSchema(val) {
+    globalSchema = val;
+    if (val.fields) {
+        for (const [k, v] of Object.entries(val.fields)) {
+            if (isGlobalSchemaField(v) && v.type.type) {
+                globalSchemaFields.set(v.type.type, v);
+            }
+        }
+    }
+}
+exports.setGlobalSchema = setGlobalSchema;
+function clearGlobalSchema() {
+    globalSchema = undefined;
+    globalSchemaFields.clear();
+}
+exports.clearGlobalSchema = clearGlobalSchema;
+// used by tests. no guarantee will always exist
+function __hasGlobalSchema() {
+    return globalSchema !== undefined;
+}
+exports.__hasGlobalSchema = __hasGlobalSchema;
+// used by tests. no guarantee will always exist
+function __getGlobalSchema() {
+    return globalSchema;
+}
+exports.__getGlobalSchema = __getGlobalSchema;
+function __getGlobalSchemaFields() {
+    return globalSchemaFields;
+}
+exports.__getGlobalSchemaFields = __getGlobalSchemaFields;
+function __getGlobalSchemaField(type) {
+    return globalSchemaFields.get(type);
+}
+exports.__getGlobalSchemaField = __getGlobalSchemaField;

package/core/loaders/assoc_edge_loader.d.ts

@@ -21,7 +21,7 @@ export declare class AssocDirectEdgeLoader<T extends AssocEdge> implements Loade
     private edgeCtr;
     private options?;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
-    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(edgeType: string, edgeCtr: AssocEdgeConstructor<T>, options?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     load(id: ID): Promise<T[]>;
     loadEdgeForID2(id: ID, id2: ID): Promise<T | undefined>;
     clearAll(): void;

package/core/loaders/object_loader.d.ts

@@ -1,29 +1,49 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
-export declare class ObjectLoader<V = Data> implements Loader<ID, V | null> {
+import * as clause from "../clause";
+export declare class ObjectLoader<TQueryData extends Data = Data, TResultData extends Data = TQueryData, K = keyof TQueryData> implements Loader<ID, TResultData | null>, Loader<clause.Clause<TQueryData, K>, TResultData[] | null> {
     private options;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
-    private loader;
+    private idLoader;
+    private clauseLoader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<V>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<TResultData>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
-    load(key: ID): Promise<V | null>;
+    load(key: ID): Promise<TResultData | null>;
+    load(key: clause.Clause<TQueryData, K>): Promise<TResultData[] | null>;
+    private loadID;
+    private loadClause;
+    clearAll(): void;
+    loadMany(keys: ID[]): Promise<Array<TResultData | null>>;
+    loadMany(keys: clause.Clause<TQueryData, K>[]): Promise<Array<TResultData[] | null>>;
+    private loadIDMany;
+    private loadClauseMany;
+    prime(data: TResultData): void;
+    primeAll(data: TResultData): void;
+}
+export declare class ObjectCountLoader<V extends Data = Data, K = keyof V> implements Loader<clause.Clause<V, K>, number> {
+    private options;
+    context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
+    private loader;
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    getOptions(): SelectDataOptions;
+    load(key: clause.Clause<V, K>): Promise<number>;
     clearAll(): void;
-    loadMany(keys: ID[]): Promise<Array<V | null>>;
-    prime(data: V): void;
-    primeAll(data: V): void;
+    loadMany(keys: clause.Clause<V, K>[]): Promise<Array<number>>;
 }
 interface ObjectLoaderOptions extends SelectDataOptions {
     instanceKey?: string;
 }
-export declare class ObjectLoaderFactory<V = Data> implements LoaderFactory<ID, V | null> {
+export declare class ObjectLoaderFactory<V extends Data = Data> implements LoaderFactory<ID, V | null>, LoaderFactory<clause.Clause<V>, V[] | null> {
     options: ObjectLoaderOptions;
     name: string;
     private toPrime;
     constructor(options: ObjectLoaderOptions);
     createLoader(context?: Context): ObjectLoader<V>;
+    createTypedLoader<TQueryData extends Data = Data, TResultData extends Data = Data, K = keyof TQueryData>(context?: Context): ObjectLoader<TQueryData, TResultData, K>;
+    createCountLoader<K = keyof V>(context?: Context): ObjectCountLoader<V, K>;
     addToPrime(factory: ObjectLoaderFactory<V>): this;
 }
 export {};

package/core/loaders/object_loader.js

@@ -26,29 +26,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectLoaderFactory = exports.ObjectLoader = void 0;
+exports.ObjectLoaderFactory = exports.ObjectCountLoader = exports.ObjectLoader = void 0;
 const dataloader_1 = __importDefault(require("dataloader"));
 const ent_1 = require("../ent");
 const clause = __importStar(require("../clause"));
 const logger_1 = require("../logger");
+const clause_1 = require("../clause");
 const loader_1 = require("./loader");
 const memoizee_1 = __importDefault(require("memoizee"));
-async function loadRowsForLoader(options, ids, context) {
+async function loadRowsForIDLoader(options, ids, context) {
     let col = options.key;
-    let cls = clause.In(col, ...ids);
-    if (options.clause) {
-        let optionClause;
-        if (typeof options.clause === "function") {
-            optionClause = options.clause();
-        }
-        else {
-            optionClause = options.clause;
-        }
-        if (optionClause) {
-            // @ts-expect-error id/string mismatch
-            cls = clause.And(cls, optionClause);
-        }
-    }
+    const cls = (0, clause_1.getCombinedClause)(options, clause.In(col, ...ids));
     const rowOptions = {
         ...options,
         clause: cls,
@@ -75,6 +63,29 @@ async function loadRowsForLoader(options, ids, context) {
     }
     return result;
 }
+async function loadRowsForClauseLoader(options, clause) {
+    const rowOptions = {
+        ...options,
+        // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
+        clause: (0, clause_1.getCombinedClause)(options, clause),
+    };
+    return (await (0, ent_1.loadRows)(rowOptions));
+}
+async function loadCountForClauseLoader(options, clause) {
+    const rowOptions = {
+        ...options,
+        // @ts-expect-error clause in LoadRowOptions doesn't take templatized version of Clause
+        clause: (0, clause_1.getCombinedClause)(options, clause),
+    };
+    const row = await (0, ent_1.loadRow)({
+        ...rowOptions,
+        fields: ["count(*) as count"],
+    });
+    if (!row) {
+        return 0;
+    }
+    return parseInt(row.count, 10);
+}
 // optional clause...
 // so ObjectLoaderFactory and createDataLoader need to take a new optional field which is a clause that's always added here
 // and we need a disableTransform which skips loader completely and uses loadRow...
@@ -89,9 +100,66 @@ function createDataLoader(options) {
             return [];
         }
         // context not needed because we're creating a loader which has its own cache which is being used here
-        return loadRowsForLoader(options, ids);
+        return loadRowsForIDLoader(options, ids);
     }, loaderOptions);
 }
+class clauseCacheMap {
+    constructor(options, count) {
+        this.options = options;
+        this.count = count;
+        this.m = new Map();
+    }
+    get(key) {
+        const key2 = key.instanceKey();
+        const ret = this.m.get(key2);
+        if (ret) {
+            (0, logger_1.log)("cache", {
+                "dataloader-cache-hit": key2 + (this.count ? ":count" : ""),
+                "tableName": this.options.tableName,
+            });
+        }
+        return ret;
+    }
+    set(key, value) {
+        return this.m.set(key.instanceKey(), value);
+    }
+    delete(key) {
+        return this.m.delete(key.instanceKey());
+    }
+    clear() {
+        return this.m.clear();
+    }
+}
+function createClauseDataLoder(options) {
+    return new dataloader_1.default(async (clauses) => {
+        if (!clauses.length) {
+            return [];
+        }
+        const ret = [];
+        for await (const clause of clauses) {
+            const data = await loadRowsForClauseLoader(options, clause);
+            ret.push(data);
+        }
+        return ret;
+    }, {
+        cacheMap: new clauseCacheMap(options),
+    });
+}
+function createClauseCountDataLoader(options) {
+    return new dataloader_1.default(async (clauses) => {
+        if (!clauses.length) {
+            return [];
+        }
+        const ret = [];
+        for await (const clause of clauses) {
+            const data = await loadCountForClauseLoader(options, clause);
+            ret.push(data);
+        }
+        return ret;
+    }, {
+        cacheMap: new clauseCacheMap(options, true),
+    });
+}
 class ObjectLoader {
     constructor(options, context, toPrime) {
         this.options = options;
@@ -101,7 +169,8 @@ class ObjectLoader {
             console.trace();
         }
         if (context) {
-            this.loader = createDataLoader(options);
+            this.idLoader = createDataLoader(options);
+            this.clauseLoader = createClauseDataLoder(options);
         }
         this.memoizedInitPrime = (0, memoizee_1.default)(this.initPrime.bind(this));
     }
@@ -123,11 +192,17 @@ class ObjectLoader {
         this.primedLoaders = primedLoaders;
     }
     async load(key) {
+        if (typeof key === "string" || typeof key === "number") {
+            return this.loadID(key);
+        }
+        return this.loadClause(key);
+    }
+    async loadID(key) {
         // simple case. we get parallelization etc
-        if (this.loader) {
+        if (this.idLoader) {
             this.memoizedInitPrime();
             // prime the result if we got primable loaders
-            const result = await this.loader.load(key);
+            const result = await this.idLoader.load(key);
             if (result && this.primedLoaders) {
                 for (const [key, loader] of this.primedLoaders) {
                     const value = result[key];
@@ -138,19 +213,7 @@ class ObjectLoader {
             }
             return result;
         }
-        let cls = clause.Eq(this.options.key, key);
-        if (this.options.clause) {
-            let optionClause;
-            if (typeof this.options.clause === "function") {
-                optionClause = this.options.clause();
-            }
-            else {
-                optionClause = this.options.clause;
-            }
-            if (optionClause) {
-                cls = clause.And(cls, optionClause);
-            }
-        }
+        const cls = (0, clause_1.getCombinedClause)(this.options, clause.Eq(this.options.key, key));
         const rowOptions = {
             ...this.options,
             clause: cls,
@@ -158,22 +221,50 @@ class ObjectLoader {
         };
         return (0, ent_1.loadRow)(rowOptions);
     }
+    async loadClause(key) {
+        if (this.clauseLoader) {
+            return this.clauseLoader.load(key);
+        }
+        return loadRowsForClauseLoader(this.options, key);
+    }
     clearAll() {
-        this.loader && this.loader.clearAll();
+        this.idLoader && this.idLoader.clearAll();
+        this.clauseLoader && this.clauseLoader.clearAll();
     }
     async loadMany(keys) {
-        if (this.loader) {
+        if (!keys.length) {
+            return [];
+        }
+        if (typeof keys[0] === "string" || typeof keys[0] === "number") {
+            return this.loadIDMany(keys);
+        }
+        return this.loadClauseMany(keys);
+    }
+    loadIDMany(keys) {
+        if (this.idLoader) {
             // @ts-expect-error TODO?
-            return this.loader.loadMany(keys);
+            return this.idLoader.loadMany(keys);
+        }
+        return loadRowsForIDLoader(this.options, keys, this.context);
+    }
+    async loadClauseMany(keys) {
+        if (this.clauseLoader) {
+            // @ts-expect-error TODO?
+            return this.clauseLoader.loadMany(keys);
+        }
+        const res = [];
+        for await (const key of keys) {
+            const rows = await loadRowsForClauseLoader(this.options, key);
+            res.push(rows);
         }
-        return loadRowsForLoader(this.options, keys, this.context);
+        return res;
     }
     prime(data) {
         // we have this data from somewhere else, prime it in the c
-        if (this.loader) {
+        if (this.idLoader) {
             const col = this.options.key;
             const key = data[col];
-            this.loader.prime(key, data);
+            this.idLoader.prime(key, data);
         }
     }
     // prime this loader and any other loaders it's aware of
@@ -190,6 +281,43 @@ class ObjectLoader {
     }
 }
 exports.ObjectLoader = ObjectLoader;
+class ObjectCountLoader {
+    constructor(options, context) {
+        this.options = options;
+        this.context = context;
+        if (context) {
+            this.loader = createClauseCountDataLoader(options);
+        }
+    }
+    getOptions() {
+        return this.options;
+    }
+    async load(key) {
+        if (this.loader) {
+            return this.loader.load(key);
+        }
+        return loadCountForClauseLoader(this.options, key);
+    }
+    clearAll() {
+        this.loader && this.loader.clearAll();
+    }
+    async loadMany(keys) {
+        if (!keys.length) {
+            return [];
+        }
+        if (this.loader) {
+            // @ts-expect-error
+            return this.loader.loadMany(keys);
+        }
+        const res = [];
+        for await (const key of keys) {
+            const r = await loadCountForClauseLoader(this.options, key);
+            res.push(r);
+        }
+        return res;
+    }
+}
+exports.ObjectCountLoader = ObjectCountLoader;
 // NOTE: if not querying for all columns
 // have to query for the id field as one of the fields
 // because it's used to maintain sort order of the queried ids
@@ -213,6 +341,15 @@ class ObjectLoaderFactory {
             return new ObjectLoader(this.options, context, this.toPrime);
         }, context);
     }
+    createTypedLoader(context) {
+        const loader = this.createLoader(context);
+        return loader;
+    }
+    createCountLoader(context) {
+        return (0, loader_1.getCustomLoader)(`${this.name}:count_loader`, () => {
+            return new ObjectCountLoader(this.options, context);
+        }, context);
+    }
     // keep track of loaders to prime. needs to be done not in the constructor
     // because there's usually self references here
     addToPrime(factory) {

package/core/loaders/query_loader.d.ts

@@ -8,7 +8,7 @@ declare class QueryDirectLoader<K extends any> implements Loader<K, Data[]> {
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private memoizedInitPrime;
     private primedLoaders;
-    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "limit" | "orderby" | "clause">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
+    constructor(options: QueryOptions, queryOptions?: Partial<Pick<import("../base").QueryableDataOptions, "clause" | "limit" | "orderby">> | undefined, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined);
     private initPrime;
     load(id: K): Promise<Data[]>;
     clearAll(): void;

package/core/query/shared_test.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonTests = void 0;
 const ent_1 = require("../ent");
+const global_schema_1 = require("../global_schema");
 const viewer_1 = require("../viewer");
 const index_1 = require("../../testutils/fake_data/index");
 const test_helpers_1 = require("../../testutils/fake_data/test_helpers");
@@ -289,7 +290,7 @@ const commonTests = (opts) => {
         return { verify, getCursor };
     }
     if (opts.globalSchema) {
-        (0, ent_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
+        (0, global_schema_1.setGlobalSchema)(test_edge_global_schema_1.testEdgeGlobalSchema);
     }
     let tdb;
     if (opts.sqlite) {

package/graphql/graphql.d.ts

@@ -40,7 +40,7 @@ export interface gqlObjectOptions {
 type gqlMutationOptions = Omit<gqlFieldOptions, "nullable" | "type"> & {
     type?: gqlFieldOptionsBase["type"];
 };
-type gqlQueryOptions = Omit<gqlFieldOptions, "nullable">;
+type gqlQueryOptions = gqlFieldOptions;
 export declare enum CustomFieldType {
     Accessor = "ACCESSOR",
     Field = "FIELD",

package/graphql/graphql.js

@@ -24,6 +24,7 @@ exports.knownAllowedNames = new Map([
     ["Float", "number"],
     ["ID", "ID"],
     ["JSON", "any"],
+    ["Node", "Ent"],
 ]);
 exports.knownDisAllowedNames = new Map([
     ["Function", true],

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./core/base";
-export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, setGlobalSchema, } from "./core/ent";
+export { loadEnt, loadCustomData, loadCustomEnts, loadCustomCount, loadEntX, loadEnts, CustomQuery, loadDerivedEnt, loadDerivedEntX, loadEntViaKey, loadEntXViaKey, performRawQuery, loadRowX, loadRow, loadRows, DataOperation, EditNodeOptions, EditNodeOperation, RawQueryOperation, EdgeOperation, DeleteNodeOperation, AssocEdge, AssocEdgeInputOptions, AssocEdgeInput, AssocEdgeData, loadEdgeData, loadEdgeDatas, loadEdges, loadUniqueEdge, loadUniqueNode, loadRawEdgeCountX, loadEdgeForID2, loadNodesByEdge, getEdgeTypeInGroup, } from "./core/ent";
+export { setGlobalSchema } from "./core/global_schema";
 import DB from "./core/db";
 export * from "./core/loaders";
 export { DB };

package/index.js

@@ -63,7 +63,8 @@ Object.defineProperty(exports, "loadRawEdgeCountX", { enumerable: true, get: fun
 Object.defineProperty(exports, "loadEdgeForID2", { enumerable: true, get: function () { return ent_1.loadEdgeForID2; } });
 Object.defineProperty(exports, "loadNodesByEdge", { enumerable: true, get: function () { return ent_1.loadNodesByEdge; } });
 Object.defineProperty(exports, "getEdgeTypeInGroup", { enumerable: true, get: function () { return ent_1.getEdgeTypeInGroup; } });
-Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return ent_1.setGlobalSchema; } });
+var global_schema_1 = require("./core/global_schema");
+Object.defineProperty(exports, "setGlobalSchema", { enumerable: true, get: function () { return global_schema_1.setGlobalSchema; } });
 const db_1 = __importDefault(require("./core/db"));
 exports.DB = db_1.default;
 __exportStar(require("./core/loaders"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha126",
+  "version": "0.1.0-alpha128",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",

package/parse_schema/parse.d.ts

@@ -83,6 +83,7 @@ interface RomeConfig {
 interface ProcessedGlobalSchema {
     globalEdges: ProcessedAssocEdge[];
     extraEdgeFields: ProcessedField[];
-    initForEdges?: boolean;
+    init?: boolean;
+    globalFields?: ProcessedField[];
 }
 export {};

package/parse_schema/parse.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSchema = void 0;
 const cosmiconfig_1 = require("cosmiconfig");
 const const_1 = require("../core/const");
+const global_schema_1 = require("../core/global_schema");
 async function processFields(src, patternName) {
     const ret = [];
     let m = {};
@@ -21,7 +22,7 @@ async function processFields(src, patternName) {
     for (const name in m) {
         const field = m[name];
         //@ts-ignore type and other changed fields with different type in ProcessedField vs Field
-        let f = { name, ...field };
+        let f = { ...field, name };
         f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
         f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
         f.hasFieldPrivacy = field.privacyPolicy !== undefined;
@@ -236,6 +237,9 @@ async function parseSchema(potentialSchemas, globalSchema) {
     let parsedGlobalSchema;
     if (globalSchema) {
         parsedGlobalSchema = await parseGlobalSchema(globalSchema);
+        // set this so that we can use it, if we're trying to process server default or anything
+        // that ends up parsing,validating and formatting fields
+        (0, global_schema_1.setGlobalSchema)(globalSchema);
     }
     for (const key in potentialSchemas) {
         const value = potentialSchemas[key];
@@ -354,9 +358,10 @@ async function parseGlobalSchema(s) {
     const ret = {
         globalEdges: [],
         extraEdgeFields: [],
-        initForEdges: !!s.extraEdgeFields ||
+        init: !!s.extraEdgeFields ||
             s.transformEdgeRead !== undefined ||
-            s.transformEdgeWrite !== undefined,
+            s.transformEdgeWrite !== undefined ||
+            s.fields !== undefined,
     };
     if (s.extraEdgeFields) {
         ret.extraEdgeFields = await processFields(s.extraEdgeFields);
@@ -364,5 +369,8 @@ async function parseGlobalSchema(s) {
     if (s.edges) {
         ret.globalEdges = processEdges(s.edges);
     }
+    if (s.fields) {
+        ret.globalFields = await processFields(s.fields);
+    }
     return ret;
 }

package/schema/field.d.ts

@@ -149,6 +149,7 @@ export interface EnumOptions extends FieldOptions {
     graphQLType?: string;
     createEnumType?: boolean;
     disableUnknownType?: boolean;
+    globalType?: string;
 }
 /**
  * @deprecated Use StringEnumField
@@ -158,7 +159,7 @@ export declare class EnumField extends BaseField implements Field {
     private values?;
     private map?;
     constructor(options: StringEnumOptions);
-    valid(val: any): boolean;
+    valid(val: any): Promise<boolean>;
     format(val: any): any;
 }
 export declare class StringEnumField extends EnumField {
@@ -173,17 +174,18 @@ declare type IntEnumMap = {
     [key: string]: number;
 };
 export interface IntegerEnumOptions extends FieldOptions {
-    map: IntEnumMap;
+    map?: IntEnumMap;
     deprecated?: IntEnumMap;
     tsType?: string;
     graphQLType?: string;
     disableUnknownType?: boolean;
+    globalType?: string;
 }
 export declare class IntegerEnumField extends BaseField implements Field {
     type: Type;
     private map;
     constructor(options: IntegerEnumOptions);
-    valid(val: any): boolean;
+    valid(val: any): Promise<boolean>;
     format(val: any): any;
 }
 export declare function IntegerEnumType(options: IntegerEnumOptions): IntegerEnumField;

package/schema/field.js

@@ -31,6 +31,8 @@ const uuid_1 = require("uuid");
 const base_1 = require("../core/base");
 const db_1 = __importStar(require("../core/db"));
 const schema_1 = require("./schema");
+const global_schema_1 = require("../core/global_schema");
+const logger_1 = require("../core/logger");
 class BaseField {
     logValue(val) {
         if (this.sensitive) {
@@ -525,10 +527,11 @@ class EnumField extends BaseField {
             type: options.tsType,
             graphQLType: options.graphQLType,
             disableUnknownType: options.disableUnknownType,
+            globalType: options.globalType,
         };
         if (!options.foreignKey) {
-            if (!options.values && !options.map) {
-                throw new Error("values or map required if not look up table enum. Look-up table enum indicated by foreignKey field");
+            if (!options.values && !options.map && !options.globalType) {
+                throw new Error("values, map or globalType required if not look up table enum. Look-up table enum indicated by foreignKey field");
             }
             if (options.values) {
                 if (!options.values.length) {
@@ -547,8 +550,8 @@ class EnumField extends BaseField {
             }
         }
         else {
-            if (options.values || options.map) {
-                throw new Error("cannot specify values or map and foreign key for lookup table enum type");
+            if (options.values || options.map || options.globalType) {
+                throw new Error("cannot specify values, map or globalType and foreign key for lookup table enum type");
             }
             if (options.createEnumType) {
                 throw new Error("cannot specify createEnumType without specifying values");
@@ -563,7 +566,20 @@ class EnumField extends BaseField {
         this.values = options.values;
         this.map = options.map;
     }
-    valid(val) {
+    async valid(val) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f) {
+                if (f.valid) {
+                    return f.valid(val);
+                }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
+            }
+        }
         // lookup table enum and indicated via presence of foreignKey
         if (!this.values && !this.map) {
             return true;
@@ -581,6 +597,13 @@ class EnumField extends BaseField {
         return false;
     }
     format(val) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                return f.format(val);
+            }
+            return val;
+        }
         return val;
     }
 }
@@ -603,21 +626,46 @@ class IntegerEnumField extends BaseField {
             graphQLType: options.graphQLType,
             deprecatedIntEnumMap: options.deprecated,
             disableUnknownType: options.disableUnknownType,
+            globalType: options.globalType,
         };
-        let count = 0;
-        for (const _ in options.map) {
-            count++;
-            break;
-        }
-        if (!count) {
-            throw new Error("need at least one entry in enum map");
-        }
         if (options.foreignKey) {
             throw new Error(`foreignKey on intEnum not supported`);
         }
-        this.map = options.map;
+        if (options.globalType) {
+            if (options.map) {
+                throw new Error(`cannot specify map and globalType`);
+            }
+            this.map = {};
+        }
+        else {
+            let count = 0;
+            for (const _ in options.map) {
+                count++;
+                break;
+            }
+            if (!count) {
+                throw new Error("need at least one entry in enum map");
+            }
+            if (!options.map) {
+                throw new Error("map required if not globalType");
+            }
+            this.map = options.map;
+        }
     }
-    valid(val) {
+    async valid(val) {
+        if (this.type?.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f) {
+                if (f.valid) {
+                    return f.valid(val);
+                }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
+            }
+        }
         // lookup table enum and indicated via presence of foreignKey
         for (const k in this.map) {
             const v = this.map[k];
@@ -628,6 +676,12 @@ class IntegerEnumField extends BaseField {
         return false;
     }
     format(val) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                return f.format(val);
+            }
+        }
         return parseInt(val);
     }
 }

package/schema/schema.d.ts

@@ -17,6 +17,7 @@ export interface GlobalSchema {
     extraEdgeFields?: FieldMap;
     transformEdgeRead?: () => Clause;
     transformEdgeWrite?: (stmt: EdgeUpdateOperation) => TransformedEdgeUpdateOperation | null;
+    fields?: FieldMap;
 }
 type FieldOverride = Pick<FieldOptions, "nullable" | "storageKey" | "serverDefault" | "unique" | "hideFromGraphQL" | "graphqlName" | "index">;
 export type FieldOverrideMap = {
@@ -171,6 +172,7 @@ export interface Type {
     intEnumMap?: IntEnumMap;
     deprecatedIntEnumMap?: IntEnumMap;
     disableUnknownType?: boolean;
+    globalType?: string;
     importType?: DeprecatedImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;

package/schema/struct_field.d.ts

@@ -1,20 +1,22 @@
 import { BaseField, ListField } from "./field";
 import { FieldOptions, Field, Type, FieldMap } from "./schema";
-export interface StructOptions extends FieldOptions {
+interface structFieldOptions extends FieldOptions {
     tsType: string;
     fields: FieldMap;
     graphQLType?: string;
     jsonNotJSONB?: boolean;
 }
-interface allStructOptions extends StructOptions {
-    jsonAsList?: boolean;
+interface GlobalStructOptions extends FieldOptions {
+    globalType: string;
 }
+export type StructOptions = structFieldOptions | GlobalStructOptions;
 export declare class StructField extends BaseField implements Field {
     private options;
+    private jsonAsList?;
     type: Type;
-    constructor(options: allStructOptions);
+    constructor(options: StructOptions, jsonAsList?: boolean | undefined);
     formatImpl(obj: any, nested?: boolean): string | Object;
-    format(obj: any, nested?: boolean): string | Object;
+    format(obj: any, nested?: boolean): any;
     private validImpl;
     valid(obj: any): Promise<boolean>;
 }
@@ -23,5 +25,5 @@ export declare function StructType(options: StructOptions): StructField & Struct
  * @deprecated use StructTypeAsList
  */
 export declare function StructListType(options: StructOptions): ListField;
-export declare function StructTypeAsList(options: allStructOptions): StructField & allStructOptions;
+export declare function StructTypeAsList(options: StructOptions): StructField & StructOptions;
 export {};

package/schema/struct_field.js

@@ -4,20 +4,24 @@ exports.StructTypeAsList = exports.StructListType = exports.StructType = exports
 const camel_case_1 = require("camel-case");
 const field_1 = require("./field");
 const schema_1 = require("./schema");
+const global_schema_1 = require("../core/global_schema");
+const logger_1 = require("../core/logger");
 class StructField extends field_1.BaseField {
-    constructor(options) {
+    constructor(options, jsonAsList) {
         super();
         this.options = options;
+        this.jsonAsList = jsonAsList;
         this.type = {
             dbType: schema_1.DBType.JSONB,
         };
         this.type.subFields = options.fields;
         this.type.type = options.tsType;
         this.type.graphQLType = options.graphQLType || options.tsType;
+        this.type.globalType = this.options.globalType;
         if (options.jsonNotJSONB) {
             this.type.dbType = schema_1.DBType.JSON;
         }
-        if (options?.jsonAsList) {
+        if (jsonAsList) {
             this.type.listElemType = {
                 dbType: schema_1.DBType.JSONB,
             };
@@ -57,7 +61,37 @@ class StructField extends field_1.BaseField {
         return JSON.stringify(ret);
     }
     format(obj, nested) {
-        if (Array.isArray(obj) && this.options.jsonAsList) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            if (f && f.format) {
+                if (JSON.stringify(this.type.listElemType) !==
+                    JSON.stringify(f?.type.listElemType)) {
+                    if (this.jsonAsList) {
+                        // handle as nested
+                        // @ts-ignore
+                        const formatted = obj.map((v) => f.format(v, true));
+                        if (nested) {
+                            return formatted;
+                        }
+                        else {
+                            return JSON.stringify(formatted);
+                        }
+                    }
+                    else {
+                        const formatted = f.format([obj], true);
+                        if (nested) {
+                            return formatted[0];
+                        }
+                        else {
+                            return JSON.stringify(formatted[0]);
+                        }
+                    }
+                }
+                // TODO handle format code
+                return f.format(obj);
+            }
+        }
+        if (Array.isArray(obj) && this.jsonAsList) {
             const ret = obj.map((v) => this.formatImpl(v, true));
             if (nested) {
                 return ret;
@@ -102,7 +136,35 @@ class StructField extends field_1.BaseField {
         return ret.every((v) => v);
     }
     async valid(obj) {
-        if (this.options.jsonAsList) {
+        if (this.type.globalType) {
+            const f = (0, global_schema_1.__getGlobalSchemaField)(this.type.globalType);
+            // list and global type is not valid.
+            if (f) {
+                if (f.valid) {
+                    if (JSON.stringify(this.type.listElemType) !==
+                        JSON.stringify(f?.type.listElemType)) {
+                        if (this.jsonAsList) {
+                            if (!Array.isArray(obj)) {
+                                return false;
+                            }
+                            // @ts-ignore
+                            const valid = await Promise.all(obj.map((v) => f.valid(v)));
+                            return valid.every((b) => b);
+                        }
+                        else {
+                            return f.valid([obj]);
+                        }
+                    }
+                    return f.valid(obj);
+                }
+                return true;
+            }
+            else {
+                (0, logger_1.log)("error", `globalType ${this.type.globalType} not found in global schema`);
+                return false;
+            }
+        }
+        if (this.jsonAsList) {
             if (!Array.isArray(obj)) {
                 return false;
             }
@@ -129,10 +191,7 @@ function StructListType(options) {
 }
 exports.StructListType = StructListType;
 function StructTypeAsList(options) {
-    let result = new StructField({
-        ...options,
-        jsonAsList: true,
-    });
+    let result = new StructField(options, true);
     return Object.assign(result, options);
 }
 exports.StructTypeAsList = StructTypeAsList;

package/schema/union_field.d.ts

@@ -15,7 +15,7 @@ export declare class UnionField extends BaseField implements FieldOptions {
     type: Type;
     m: Map<Object, string>;
     constructor(options: UnionOptions);
-    format(obj: any): string | Object;
+    format(obj: any): any;
     private validField;
     valid(obj: any): Promise<boolean>;
 }