@snowtop/ent 0.1.0-alpha16 → 0.1.0-alpha160-test1

package/schema/schema.d.ts

@@ -1,6 +1,7 @@
 import { Data, Ent, LoaderInfo, PrivacyPolicy, Viewer } from "../core/base";
-import { Builder } from "../action/action";
+import { Builder, Changeset } from "../action/action";
 import { Clause } from "../core/clause";
+import { AssocEdgeInput } from "../action/operations";
 export declare type FieldMap = {
     [key: string]: Field;
 };
@@ -8,11 +9,23 @@ interface FieldInfo {
     dbCol: string;
     inputKey: string;
 }
-export declare type FieldInfoMap = {
+export type FieldInfoMap = {
     [key: string]: FieldInfo;
 };
+export interface GlobalSchema {
+    edges?: Edge[];
+    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 = {
+    [key: string]: FieldOverride;
+};
 export default interface Schema {
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    fieldOverrides?: FieldOverrideMap;
     tableName?: string;
     patterns?: Pattern[];
     edges?: Edge[];
@@ -25,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;
@@ -43,6 +60,7 @@ export interface EdgeAction {
     hideFromGraphQL?: boolean;
     graphQLName?: string;
     actionOnlyFields?: ActionField[];
+    canViewerDo?: boolean | CanViewerDo;
 }
 export interface InverseAssocEdge {
     name: string;
@@ -54,6 +72,7 @@ export interface EdgeGroupAction {
     hideFromGraphQL?: boolean;
     graphQLName?: string;
     actionOnlyFields?: ActionField[];
+    canViewerDo?: boolean | CanViewerDo;
 }
 export interface AssocEdgeGroup {
     name: string;
@@ -61,18 +80,30 @@ export interface AssocEdgeGroup {
     tableName?: string;
     assocEdges: AssocEdge[];
     statusEnums?: string[];
-    nullStates: string | string[];
+    viewerBased?: boolean;
+    nullStates?: string | string[];
     nullStateFn?: string;
     edgeAction?: EdgeGroupAction;
 }
-export declare type Edge = AssocEdge;
+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 | Field[];
+    fields: FieldMap;
     disableMixin?: boolean;
     edges?: Edge[];
     transformRead?: () => Clause;
-    transformWrite?: <T extends Ent>(stmt: UpdateOperation<T>) => TransformedUpdateOperation<T> | null;
+    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;
     transformsUpdate?: boolean;
@@ -82,16 +113,25 @@ export declare enum SQLStatementOperation {
     Update = "update",
     Delete = "delete"
 }
-export interface UpdateOperation<T extends Ent> {
+export interface EdgeUpdateOperation {
+    op: SQLStatementOperation;
+    edge: AssocEdgeInput;
+}
+export interface TransformedEdgeUpdateOperation {
     op: SQLStatementOperation;
-    existingEnt: T | null;
-    viewer: Viewer;
+    data?: Data;
+}
+export interface UpdateOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    op: SQLStatementOperation;
+    builder: Builder<TEnt, TViewer, any>;
+    input: Data;
     data?: Map<string, any>;
 }
-export interface TransformedUpdateOperation<T extends Ent> {
+export interface TransformedUpdateOperation<T extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     op: SQLStatementOperation;
     data?: Data;
     existingEnt?: T | null;
+    changeset?(): Promise<Changeset> | Changeset;
 }
 export declare enum DBType {
     UUID = "UUID",
@@ -107,19 +147,27 @@ export declare enum DBType {
     JSONB = "JSONB",
     Enum = "Enum",
     StringEnum = "StringEnum",
+    IntEnum = "IntEnum",
     Date = "Date",
     Time = "Time",
     Timetz = "Timetz",
     List = "List"
 }
-export interface ImportType {
+export interface DeprecatedImportType {
     path: string;
     type: string;
     [x: string]: any;
 }
+export interface ConvertType {
+    path: string;
+    function: string;
+}
 declare type EnumMap = {
     [key: string]: string;
 };
+declare type IntEnumMap = {
+    [key: string]: number;
+};
 export interface Type {
     dbType: DBType;
     listElemType?: Type;
@@ -127,9 +175,14 @@ export interface Type {
     graphQLType?: string;
     values?: string[];
     enumMap?: EnumMap;
-    importType?: ImportType;
+    intEnumMap?: IntEnumMap;
+    deprecatedIntEnumMap?: IntEnumMap;
+    disableUnknownType?: boolean;
+    globalType?: string;
+    importType?: DeprecatedImportType;
     subFields?: FieldMap;
     unionFields?: FieldMap;
+    [x: string]: any;
 }
 export interface ForeignKey {
     schema: string;
@@ -137,20 +190,29 @@ export interface ForeignKey {
     name?: string;
     disableIndex?: boolean;
     disableBuilderType?: boolean;
+    [x: string]: any;
 }
-declare type getLoaderInfoFn = (type: string) => LoaderInfo;
+type getLoaderInfoFn = (type: string) => LoaderInfo;
 export interface InverseFieldEdge {
     name: string;
     edgeConstName?: string;
     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;
 }
 export interface FieldOptions {
     nullable?: boolean;
@@ -158,53 +220,66 @@ export interface FieldOptions {
     serverDefault?: any;
     unique?: boolean;
     hideFromGraphQL?: boolean;
-    private?: boolean;
+    private?: boolean | PrivateOptions;
     sensitive?: boolean;
     graphqlName?: string;
     index?: boolean;
     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;
+    dbOnly?: boolean;
     [x: string]: any;
 }
 export interface PolymorphicOptions {
+    name?: string;
     types?: string[];
     hideFromInverseGraphQL?: boolean;
     disableBuilderType?: boolean;
+    serverDefault?: any;
+    edgeConstName?: string;
 }
 export interface Field extends FieldOptions {
     type: Type;
     valid?(val: any): Promise<boolean> | boolean;
+    validateWithFullData?(val: any, builder: Builder<any>): boolean | Promise<boolean>;
     format?(val: any, nested?: boolean): any;
     logValue(val: any): any;
 }
 export interface SchemaConstructor {
     new (): Schema;
 }
-export declare type SchemaInputType = Schema | SchemaConstructor;
+export type SchemaInputType = Schema | SchemaConstructor;
 export declare function getSchema(value: SchemaInputType): Schema;
 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;
     instanceKey?: string;
 }
 export declare function getObjectLoaderProperties(value: SchemaInputType, tableName: string): objectLoaderOptions | undefined;
-export declare function getTransformedUpdateOp<T extends Ent>(value: SchemaInputType, stmt: UpdateOperation<T>): TransformedUpdateOperation<T> | null;
+export declare function getTransformedUpdateOp<TEnt extends Ent<TViewer>, TViewer extends Viewer>(value: SchemaInputType, stmt: UpdateOperation<TEnt, TViewer>): TransformedUpdateOperation<TEnt> | null;
 export declare enum ActionOperation {
     Create = 1,
     Edit = 2,
@@ -214,15 +289,18 @@ export declare enum ActionOperation {
     RemoveEdge = 32,
     EdgeGroup = 64
 }
-declare type actionFieldType = "ID" | "Boolean" | "Int" | "Float" | "String" | "Time" | "Object";
-declare type NullableListOptions = "contents" | "contentsAndList";
+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[];
+    hideFromGraphQL?: boolean;
+    [x: string]: any;
 }
 export interface Action {
     operation: ActionOperation;
@@ -236,6 +314,12 @@ 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;
@@ -246,6 +330,7 @@ export interface Constraint {
     columns: string[];
     fkey?: ForeignKeyInfo;
     condition?: string;
+    [x: string]: any;
 }
 export interface FullTextWeight {
     A?: string[];
@@ -259,17 +344,21 @@ export interface FullText {
     languageColumn?: string;
     indexType?: "gin" | "gist";
     weights?: FullTextWeight;
+    [x: string]: any;
 }
 export interface Index {
     name: string;
     columns: string[];
     unique?: boolean;
     fulltext?: FullText;
+    indexType?: "gin" | "btree";
+    [x: string]: any;
 }
 export interface ForeignKeyInfo {
     tableName: string;
     ondelete?: "RESTRICT" | "CASCADE" | "SET NULL" | "SET DEFAULT" | "NO ACTION";
     columns: string[];
+    [x: string]: any;
 }
 export declare enum ConstraintType {
     PrimaryKey = "primary",

package/schema/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.getFieldsWithPrivacy = exports.getStorageKey = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
+exports.ConstraintType = exports.optionalField = exports.requiredField = exports.NoFields = exports.ActionOperation = exports.getTransformedUpdateOp = exports.getObjectLoaderProperties = exports.getTransformedReadClause = exports.getFieldsForCreateAction = exports.getFieldsWithEditPrivacy = exports.getFieldsWithPrivacy = exports.getStorageKey = exports.getFields = exports.getSchema = exports.DBType = exports.SQLStatementOperation = void 0;
 const snake_case_1 = require("snake-case");
 // we also want this transformation to exist on a per-action basis
 // if it exists on an action, we don't do the global schema transformation
@@ -35,6 +35,7 @@ var DBType;
     DBType["JSONB"] = "JSONB";
     DBType["Enum"] = "Enum";
     DBType["StringEnum"] = "StringEnum";
+    DBType["IntEnum"] = "IntEnum";
     DBType["Date"] = "Date";
     DBType["Time"] = "Time";
     DBType["Timetz"] = "Timetz";
@@ -55,21 +56,11 @@ exports.getSchema = getSchema;
 function getFields(value) {
     const schema = getSchema(value);
     function addFields(fields) {
-        if (Array.isArray(fields)) {
-            for (const field of fields) {
-                const name = field.name;
-                if (!name) {
-                    throw new Error(`name required`);
-                }
-                if (field.getDerivedFields !== undefined) {
-                    addFields(field.getDerivedFields(name));
-                }
-                m.set(name, field);
-            }
-            return;
-        }
         for (const name in fields) {
             const field = fields[name];
+            if (field.dbOnly) {
+                continue;
+            }
             if (field.getDerivedFields !== undefined) {
                 addFields(field.getDerivedFields(name));
             }
@@ -94,52 +85,45 @@ function getStorageKey(field, fieldName) {
 }
 exports.getStorageKey = getStorageKey;
 // returns a mapping of storage key to field privacy
-function getFieldsWithPrivacy(value, fieldMap) {
+function getFieldsWithPrivacy(value, fieldInfoMap) {
+    return getFieldsWithPrivacyImpl(value, fieldInfoMap, ["privacyPolicy"]);
+}
+exports.getFieldsWithPrivacy = getFieldsWithPrivacy;
+function getFieldsWithEditPrivacy(value, fieldInfoMap) {
+    return getFieldsWithPrivacyImpl(value, fieldInfoMap, ["editPrivacyPolicy"]);
+}
+exports.getFieldsWithEditPrivacy = getFieldsWithEditPrivacy;
+function getFieldsForCreateAction(value, fieldInfoMap) {
+    return getFieldsWithPrivacyImpl(value, fieldInfoMap, [
+        "createOnlyOverrideEditPrivacyPolicy",
+        "editPrivacyPolicy",
+    ]);
+}
+exports.getFieldsForCreateAction = getFieldsForCreateAction;
+function getFieldsWithPrivacyImpl(value, fieldInfoMap, keys) {
     const schema = getSchema(value);
     function addFields(fields) {
-        if (Array.isArray(fields)) {
-            for (const field of fields) {
-                const name = field.name;
-                if (!field.name) {
-                    throw new Error(`name required`);
-                }
-                if (field.getDerivedFields !== undefined) {
-                    addFields(field.getDerivedFields(name));
-                }
-                if (field.privacyPolicy) {
-                    let privacyPolicy;
-                    if (typeof field.privacyPolicy === "function") {
-                        privacyPolicy = field.privacyPolicy();
-                    }
-                    else {
-                        privacyPolicy = field.privacyPolicy;
-                    }
-                    const info = fieldMap[name];
-                    if (!info) {
-                        throw new Error(`field with name ${name} not passed in fieldMap`);
-                    }
-                    m.set(info.dbCol, privacyPolicy);
-                }
-            }
-        }
         for (const name in fields) {
             const field = fields[name];
+            if (field.dbOnly) {
+                continue;
+            }
             if (field.getDerivedFields !== undefined) {
                 addFields(field.getDerivedFields(name));
             }
-            if (field.privacyPolicy) {
-                let privacyPolicy;
-                if (typeof field.privacyPolicy === "function") {
-                    privacyPolicy = field.privacyPolicy();
-                }
-                else {
-                    privacyPolicy = field.privacyPolicy;
-                }
-                const info = fieldMap[name];
-                if (!info) {
-                    throw new Error(`field with name ${name} not passed in fieldMap`);
+            for (const key of keys) {
+                let privacyPolicy = field[key];
+                if (privacyPolicy) {
+                    if (typeof privacyPolicy === "function") {
+                        privacyPolicy = privacyPolicy();
+                    }
+                    const info = fieldInfoMap[name];
+                    if (!info) {
+                        throw new Error(`field with name ${name} not passed in fieldMap`);
+                    }
+                    m.set(info.dbCol, privacyPolicy);
+                    break;
                 }
-                m.set(info.dbCol, privacyPolicy);
             }
         }
     }
@@ -152,7 +136,6 @@ function getFieldsWithPrivacy(value, fieldMap) {
     addFields(schema.fields);
     return m;
 }
-exports.getFieldsWithPrivacy = getFieldsWithPrivacy;
 function getTransformedReadClause(value) {
     const schema = getSchema(value);
     if (!schema.patterns) {
@@ -168,6 +151,9 @@ function getTransformedReadClause(value) {
     return;
 }
 exports.getTransformedReadClause = getTransformedReadClause;
+// would like to avoid calling this so that itwe don't run into circular dependencies
+// but the fact that it returns a clause makes it hard since we don't control the patterns...
+// we can make each clause return a format that can be extrapolated and used in codegen...
 function getObjectLoaderProperties(value, tableName) {
     return {
         clause: () => getTransformedReadClause(value),
@@ -209,6 +195,9 @@ var ActionOperation;
     // RemoveEdge is used to provide the ability to remove an edge in an AssociationEdge.
     ActionOperation[ActionOperation["RemoveEdge"] = 32] = "RemoveEdge";
     // EdgeGroup is used to provide the ability to edit an edge group in an AssociationEdgeGroup.
+    // if you want to clear this edge group e.g. any set edge with id1 and id2,
+    // you should create a custom action that takes the id as an action only field,
+    // and then calls `clearEdgeTypeInGroup` in a trigger to clear
     ActionOperation[ActionOperation["EdgeGroup"] = 64] = "EdgeGroup";
 })(ActionOperation = exports.ActionOperation || (exports.ActionOperation = {}));
 // sentinel that indicates an action has no fields

package/schema/struct_field.d.ts

@@ -1,17 +1,29 @@
 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 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: StructOptions);
-    format(obj: any, nested?: boolean): string | Object;
+    constructor(options: StructOptions, jsonAsList?: boolean | undefined);
+    formatImpl(obj: any, nested?: boolean): string | Object;
+    format(obj: any, nested?: boolean): any;
+    private validImpl;
     valid(obj: any): Promise<boolean>;
 }
 export declare function StructType(options: StructOptions): StructField & StructOptions;
+/**
+ * @deprecated use StructTypeAsList
+ */
 export declare function StructListType(options: StructOptions): ListField;
+export declare function StructTypeAsList(options: StructOptions): StructField & StructOptions;
+export {};