@snowtop/ent 0.1.0-alpha99 → 0.1.0

package/parse_schema/parse.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchema = void 0;
+exports.parseSchema = exports.processFields = 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 = {};
@@ -20,10 +22,11 @@ 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;
+        f.hasEditFieldPrivacy = field.editPrivacyPolicy !== undefined;
         if (field.polymorphic) {
             // convert boolean into object
             // we keep boolean as an option to keep API simple
@@ -84,6 +87,7 @@ async function processFields(src, patternName) {
     }
     return ret;
 }
+exports.processFields = processFields;
 async function transformServerDefault(name, f, value) {
     if (f.valid) {
         if (!(await f.valid(value))) {
@@ -158,6 +162,23 @@ async function processPattern(patterns, pattern, processedSchema) {
     // flag transformsSelect
     if (pattern.transformRead) {
         ret.transformsSelect = true;
+        if (pattern.transformReadCodegen_BETA) {
+            const r = pattern.transformReadCodegen_BETA();
+            if (typeof r === "string") {
+                ret.transformsLoaderCodegen = {
+                    code: r,
+                    imports: [
+                        {
+                            importPath: const_1.PACKAGE,
+                            import: "query",
+                        },
+                    ],
+                };
+            }
+            else {
+                ret.transformsLoaderCodegen = r;
+            }
+        }
     }
     if (patterns[name] === undefined) {
         // intentionally processing separately and not passing pattern.name
@@ -182,30 +203,39 @@ var NullableResult;
     NullableResult["ITEM"] = "true";
 })(NullableResult || (NullableResult = {}));
 function processAction(action) {
-    if (!action.actionOnlyFields) {
-        return { ...action };
-    }
-    let ret = { ...action };
-    let actionOnlyFields = action.actionOnlyFields.map((f) => {
-        let f2 = f;
-        if (!f.nullable) {
-            delete f2.nullable;
-            return f2;
-        }
-        if (typeof f.nullable === "boolean") {
-            f2.nullable = NullableResult.ITEM;
-        }
-        else {
-            if (f.nullable === "contentsAndList") {
-                f2.nullable = NullableResult.CONTENTS_AND_LIST;
+    const ret = { ...action };
+    if (action.actionOnlyFields !== undefined) {
+        let actionOnlyFields = action.actionOnlyFields.map((f) => {
+            let f2 = f;
+            if (!f.nullable) {
+                delete f2.nullable;
+                return f2;
+            }
+            if (typeof f.nullable === "boolean") {
+                f2.nullable = NullableResult.ITEM;
             }
             else {
-                f2.nullable = NullableResult.CONTENTS;
+                if (f.nullable === "contentsAndList") {
+                    f2.nullable = NullableResult.CONTENTS_AND_LIST;
+                }
+                else if (f.nullable === "contents") {
+                    f2.nullable = NullableResult.CONTENTS;
+                }
+                else if (f.nullable === "true") {
+                    // shouldn't happen but ran into weirdness where it did...
+                    f2.nullable = NullableResult.ITEM;
+                }
             }
+            return f2;
+        });
+        ret.actionOnlyFields = actionOnlyFields;
+    }
+    if (action.canViewerDo !== undefined) {
+        if (typeof action.canViewerDo !== "object") {
+            delete ret.canViewerDo;
+            ret.canViewerDo = {};
         }
-        return f2;
-    });
-    ret.actionOnlyFields = actionOnlyFields;
+    }
     return ret;
 }
 async function parseSchema(potentialSchemas, globalSchema) {
@@ -214,6 +244,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];
@@ -241,6 +274,10 @@ async function parseSchema(potentialSchemas, globalSchema) {
             actions: schema.actions?.map((action) => processAction(action)) || [],
             assocEdges: [],
             assocEdgeGroups: [],
+            customGraphQLInterfaces: schema.customGraphQLInterfaces,
+            supportUpsert: schema.supportUpsert,
+            showCanViewerSee: schema.showCanViewerSee,
+            showCanViewerEdit: schema.showCanViewerEdit,
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
@@ -254,6 +291,10 @@ async function parseSchema(potentialSchemas, globalSchema) {
                         throw new Error(`can only have one pattern which transforms default querying behavior`);
                     }
                     processedSchema.transformsSelect = true;
+                    if (ret.transformsLoaderCodegen) {
+                        processedSchema.transformsLoaderCodegen =
+                            ret.transformsLoaderCodegen;
+                    }
                 }
                 if (ret.transformsDelete) {
                     if (processedSchema.transformsDelete) {
@@ -328,9 +369,11 @@ 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,
+        transformsEdges: !!s.transformEdgeRead || !!s.transformEdgeWrite,
     };
     if (s.extraEdgeFields) {
         ret.extraEdgeFields = await processFields(s.extraEdgeFields);
@@ -338,5 +381,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/base_schema.d.ts

@@ -19,6 +19,10 @@ export declare class EntSchema implements Schema {
     constraints: Constraint[] | undefined;
     indices: Index[] | undefined;
     hideFromGraphQL?: boolean;
+    customGraphQLInterfaces?: string[] | undefined;
+    supportUpsert?: boolean | undefined;
+    showCanViewerSee?: boolean | undefined;
+    showCanViewerEdit?: boolean | undefined;
     constructor(cfg: SchemaConfig);
 }
 export declare class EntSchemaWithTZ implements Schema {
@@ -36,6 +40,10 @@ export declare class EntSchemaWithTZ implements Schema {
     constraints: Constraint[] | undefined;
     indices: Index[] | undefined;
     hideFromGraphQL?: boolean;
+    customGraphQLInterfaces?: string[] | undefined;
+    supportUpsert?: boolean | undefined;
+    showCanViewerSee?: boolean | undefined;
+    showCanViewerEdit?: boolean | undefined;
     constructor(cfg: SchemaConfig);
 }
 export declare abstract class BaseEntSchema {

package/schema/base_schema.js

@@ -17,6 +17,7 @@ let tsFields = {
         defaultValueOnCreate: () => {
             return new Date();
         },
+        onlyUpdateIfOtherFieldsBeingSet_BETA: true,
         defaultValueOnEdit: () => {
             return new Date();
         },
@@ -87,6 +88,11 @@ class EntSchema {
         this.constraints = cfg.constraints;
         this.indices = cfg.indices;
         this.hideFromGraphQL = cfg.hideFromGraphQL;
+        // TODO annoying that have to list these...
+        this.customGraphQLInterfaces = cfg.customGraphQLInterfaces;
+        this.supportUpsert = cfg.supportUpsert;
+        this.showCanViewerSee = cfg.showCanViewerSee;
+        this.showCanViewerEdit = cfg.showCanViewerEdit;
     }
 }
 exports.EntSchema = EntSchema;
@@ -114,6 +120,11 @@ class EntSchemaWithTZ {
         this.constraints = cfg.constraints;
         this.indices = cfg.indices;
         this.hideFromGraphQL = cfg.hideFromGraphQL;
+        // TODO annoying that have to list these...
+        this.customGraphQLInterfaces = cfg.customGraphQLInterfaces;
+        this.supportUpsert = cfg.supportUpsert;
+        this.showCanViewerSee = cfg.showCanViewerSee;
+        this.showCanViewerEdit = cfg.showCanViewerEdit;
     }
 }
 exports.EntSchemaWithTZ = EntSchemaWithTZ;

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,16 +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

@@ -26,11 +26,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UUIDListType = exports.IntegerEnumListType = exports.EnumListType = exports.DateListType = exports.TimetzListType = exports.TimeListType = exports.TimestamptzListType = exports.TimestampListType = exports.BooleanListType = exports.BigIntegerListType = exports.FloatListType = exports.IntegerListType = exports.IntListType = exports.StringListType = exports.ListField = exports.IntegerEnumType = exports.IntegerEnumField = exports.EnumType = exports.StringEnumField = exports.EnumField = exports.DateType = exports.DateField = exports.TimetzType = exports.TimeType = exports.TimeField = exports.leftPad = exports.TimestamptzType = exports.TimestampType = exports.TimestampField = exports.StringType = exports.PolymorphicStringField = exports.StringField = exports.BooleanType = exports.BooleanField = exports.FloatType = exports.FloatField = exports.BigIntegerType = exports.BigIntegerField = exports.IntegerType = exports.IntegerField = exports.NumberField = exports.UUIDType = exports.UUIDField = exports.BaseField = void 0;
 const luxon_1 = require("luxon");
 const camel_case_1 = require("camel-case");
-const util_1 = require("util");
+const types_1 = require("util/types");
 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;
     }
 }
@@ -602,21 +625,47 @@ class IntegerEnumField extends BaseField {
             type: options.tsType,
             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];
@@ -627,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);
     }
 }
@@ -672,7 +727,7 @@ class ListField extends BaseField {
             return true;
         }
         const res = valid.apply(this.field, [val[0]]);
-        if (util_1.types.isPromise(res)) {
+        if ((0, types_1.isPromise)(res)) {
             const ret = await Promise.all(val.map(async (v) => await valid.apply(this.field, [v])));
             return ret.every((v) => v);
         }

package/schema/index.d.ts

@@ -1,6 +1,6 @@
 import Schema from "./schema";
 export { Schema };
-export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, } from "./schema";
+export { Field, AssocEdge, AssocEdgeGroup, InverseAssocEdge, Edge, Pattern, DBType, Type, FieldOptions, SchemaConstructor, SchemaInputType, getFields, getFieldsWithPrivacy, getFieldsWithEditPrivacy, getStorageKey, ActionOperation, Action, EdgeAction, NoFields, FieldMap, Constraint, Index, ConstraintType, ForeignKeyInfo, requiredField, optionalField, UpdateOperation, TransformedUpdateOperation, SQLStatementOperation, EdgeUpdateOperation, TransformedEdgeUpdateOperation, getTransformedReadClause, getObjectLoaderProperties, GlobalSchema, ActionField, } from "./schema";
 export { Timestamps, Node, BaseEntSchema, BaseEntSchemaWithTZ, EntSchema, EntSchemaWithTZ, SchemaConfig, } from "./base_schema";
 export * from "./field";
 export * from "./json_field";

package/schema/index.js

@@ -14,11 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntSchemaWithTZ = exports.EntSchema = exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
+exports.EntSchemaWithTZ = exports.EntSchema = exports.BaseEntSchemaWithTZ = exports.BaseEntSchema = exports.Node = exports.Timestamps = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.SQLStatementOperation = exports.optionalField = exports.requiredField = exports.ConstraintType = exports.NoFields = exports.ActionOperation = exports.getStorageKey = exports.getFieldsWithEditPrivacy = exports.getFieldsWithPrivacy = exports.getFields = exports.DBType = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "DBType", { enumerable: true, get: function () { return schema_1.DBType; } });
 Object.defineProperty(exports, "getFields", { enumerable: true, get: function () { return schema_1.getFields; } });
 Object.defineProperty(exports, "getFieldsWithPrivacy", { enumerable: true, get: function () { return schema_1.getFieldsWithPrivacy; } });
+Object.defineProperty(exports, "getFieldsWithEditPrivacy", { enumerable: true, get: function () { return schema_1.getFieldsWithEditPrivacy; } });
 Object.defineProperty(exports, "getStorageKey", { enumerable: true, get: function () { return schema_1.getStorageKey; } });
 Object.defineProperty(exports, "ActionOperation", { enumerable: true, get: function () { return schema_1.ActionOperation; } });
 Object.defineProperty(exports, "NoFields", { enumerable: true, get: function () { return schema_1.NoFields; } });

package/schema/json_field.d.ts

@@ -1,8 +1,8 @@
-import { FieldOptions, Type, Field, ImportType } from "./schema";
+import { FieldOptions, Type, Field, DeprecatedImportType } from "./schema";
 import { BaseField, ListField } from "./field";
 export interface JSONOptions extends FieldOptions {
     validator?: (val: any) => boolean;
-    importType?: ImportType;
+    importType?: DeprecatedImportType;
 }
 interface allJSONOptions extends JSONOptions {
     jsonAsList?: boolean;
@@ -11,7 +11,7 @@ export declare class JSONField extends BaseField implements Field {
     private options?;
     type: Type;
     constructor(jsonb: boolean, options?: allJSONOptions | undefined);
-    format(val: any): string;
+    format(val: any, nested?: boolean): any;
     valid(val: any): boolean;
 }
 export declare function JSONType(options?: JSONOptions): JSONField;

package/schema/json_field.js

@@ -22,7 +22,10 @@ class JSONField extends field_1.BaseField {
             };
         }
     }
-    format(val) {
+    format(val, nested) {
+        if (nested) {
+            return val;
+        }
         return JSON.stringify(val);
     }
     valid(val) {

package/schema/schema.d.ts

@@ -1,7 +1,7 @@
 import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
 import { Builder, Changeset } from "../action/action";
 import { Clause } from "../core/clause";
-import { AssocEdgeInput } from "../core/ent";
+import { AssocEdgeInput } from "../action/operations";
 export declare type FieldMap = {
     [key: string]: Field;
 };
@@ -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 = {
@@ -37,6 +38,10 @@ export default interface Schema {
     constraints?: Constraint[];
     indices?: Index[];
     hideFromGraphQL?: boolean;
+    customGraphQLInterfaces?: string[];
+    supportUpsert?: boolean;
+    showCanViewerSee?: boolean;
+    showCanViewerEdit?: boolean;
 }
 export interface AssocEdge {
     name: string;
@@ -55,6 +60,7 @@ export interface EdgeAction {
     hideFromGraphQL?: boolean;
     graphQLName?: string;
     actionOnlyFields?: ActionField[];
+    canViewerDo?: boolean | CanViewerDo;
 }
 export interface InverseAssocEdge {
     name: string;
@@ -66,6 +72,7 @@ export interface EdgeGroupAction {
     hideFromGraphQL?: boolean;
     graphQLName?: string;
     actionOnlyFields?: ActionField[];
+    canViewerDo?: boolean | CanViewerDo;
 }
 export interface AssocEdgeGroup {
     name: string;
@@ -79,12 +86,23 @@ export interface AssocEdgeGroup {
     edgeAction?: EdgeGroupAction;
 }
 export type Edge = AssocEdge;
+export interface ImportPath {
+    importPath: string;
+    import: string;
+    defaultImport?: boolean;
+    originalImport?: string;
+}
+export interface TransformReadBetaResult {
+    code: string;
+    imports: ImportPath[];
+}
 export interface Pattern {
     name: string;
     fields: FieldMap;
     disableMixin?: boolean;
     edges?: Edge[];
     transformRead?: () => Clause;
+    transformReadCodegen_BETA?: () => string | TransformReadBetaResult;
     transformWrite?: <T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(stmt: UpdateOperation<T, TViewer>) => TransformedUpdateOperation<T, TViewer> | null;
     transformsDelete?: boolean;
     transformsInsert?: boolean;
@@ -135,7 +153,7 @@ export declare enum DBType {
     Timetz = "Timetz",
     List = "List"
 }
-export interface ImportType {
+export interface DeprecatedImportType {
     path: string;
     type: string;
     [x: string]: any;
@@ -160,7 +178,8 @@ export interface Type {
     intEnumMap?: IntEnumMap;
     deprecatedIntEnumMap?: IntEnumMap;
     disableUnknownType?: boolean;
-    importType?: ImportType;
+    globalType?: string;
+    importType?: DeprecatedImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;
     [x: string]: any;
@@ -180,12 +199,17 @@ export interface InverseFieldEdge {
     tableName?: string;
     hideFromGraphQL?: boolean;
 }
+export interface IndexEdgeOptions {
+    name: string;
+}
 export interface FieldEdge {
     schema: string;
     inverseEdge?: string | InverseFieldEdge;
+    indexEdge?: IndexEdgeOptions;
     enforceSchema?: boolean;
     getLoaderInfoFromSchema?: getLoaderInfoFn;
     disableBuilderType?: boolean;
+    edgeConstName?: string;
 }
 interface PrivateOptions {
     exposeToActions?: boolean;
@@ -203,14 +227,18 @@ export interface FieldOptions {
     foreignKey?: ForeignKey;
     fieldEdge?: FieldEdge;
     primaryKey?: boolean;
+    immutable?: boolean;
     disableUserEditable?: boolean;
     disableUserGraphQLEditable?: boolean;
     defaultValueOnCreate?(builder: Builder<Ent>, input: Data): any;
     defaultToViewerOnCreate?: boolean;
+    onlyUpdateIfOtherFieldsBeingSet_BETA?: boolean;
     defaultValueOnEdit?(builder: Builder<Ent>, input: Data): any;
     derivedWhenEmbedded?: boolean;
     polymorphic?: boolean | PolymorphicOptions;
     privacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
+    editPrivacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
+    createOnlyOverrideEditPrivacyPolicy?: PrivacyPolicy | (() => PrivacyPolicy);
     getDerivedFields?(name: string): FieldMap;
     convert?: ConvertType;
     fetchOnDemand?: boolean;
@@ -223,6 +251,7 @@ export interface PolymorphicOptions {
     hideFromInverseGraphQL?: boolean;
     disableBuilderType?: boolean;
     serverDefault?: any;
+    edgeConstName?: string;
 }
 export interface Field extends FieldOptions {
     type: Type;
@@ -241,7 +270,9 @@ export declare function getFields(value: SchemaInputType): Map<string, Field>;
  * @deprecated should only be used by tests
  */
 export declare function getStorageKey(field: Field, fieldName: string): string;
-export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldMap: FieldInfoMap): Map<string, PrivacyPolicy>;
+export declare function getFieldsWithPrivacy(value: SchemaInputType, fieldInfoMap: FieldInfoMap): Map<string, PrivacyPolicy>;
+export declare function getFieldsWithEditPrivacy(value: SchemaInputType, fieldInfoMap: FieldInfoMap): Map<string, PrivacyPolicy>;
+export declare function getFieldsForCreateAction(value: SchemaInputType, fieldInfoMap: FieldInfoMap): Map<string, PrivacyPolicy>;
 export declare function getTransformedReadClause(value: SchemaInputType): Clause | undefined;
 interface objectLoaderOptions {
     clause?: () => Clause | undefined;
@@ -258,12 +289,13 @@ export declare enum ActionOperation {
     RemoveEdge = 32,
     EdgeGroup = 64
 }
-type actionFieldType = "ID" | "Boolean" | "Int" | "Float" | "String" | "Time" | "Object";
+type actionFieldType = "ID" | "Boolean" | "Int" | "Float" | "String" | "Time" | "JSON" | "Object";
 type NullableListOptions = "contents" | "contentsAndList";
 export interface ActionField {
     name: string;
     type: actionFieldType;
     nullable?: boolean | NullableListOptions;
+    optional?: boolean;
     list?: boolean;
     actionName?: string;
     excludedFields?: string[];
@@ -282,8 +314,13 @@ export interface Action {
     optionalFields?: string[];
     requiredFields?: string[];
     noFields?: boolean;
+    canViewerDo?: boolean | CanViewerDo;
     [x: string]: any;
 }
+export interface CanViewerDo {
+    addAllFields?: boolean;
+    inputFields?: string[];
+}
 export declare const NoFields = "__NO_FIELDS__";
 export declare function requiredField(field: string): string;
 export declare function optionalField(field: string): string;