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

package/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -25,13 +29,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.DeleteNodeOperation = exports.EdgeOperation = exports.EditNodeOperation = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
-exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = void 0;
+exports.DenyIfViewerInboundEdgeExistsRule = exports.DenyIfEdgeExistsRule = exports.AllowIfViewerOutboundEdgeExistsRule = exports.AllowIfViewerInboundEdgeExistsRule = exports.AllowIfEdgeExistsRule = exports.DenyIfViewerEqualsRule = exports.AllowIfViewerEqualsRule = exports.DenyIfEntPropertyIsRule = exports.AllowIfEntPropertyIsRule = exports.AllowIfViewerIsEntPropertyRule = exports.AllowIfViewerIsRule = exports.AllowIfFuncRule = exports.AllowIfViewerRule = exports.AllowIfHasIdentity = exports.DenyIfLoggedOutRule = exports.DenyIfLoggedInRule = exports.AlwaysDenyRule = exports.AlwaysAllowRule = exports.EntPrivacyError = exports.DB = exports.setGlobalSchema = exports.DeleteNodeOperation = exports.EdgeOperation = exports.RawQueryOperation = exports.EditNodeOperation = exports.getEdgeTypeInGroup = exports.loadNodesByEdge = exports.loadEdgeForID2 = exports.loadRawEdgeCountX = exports.loadUniqueNode = exports.loadUniqueEdge = exports.loadEdges = exports.loadEdgeDatas = exports.loadEdgeData = exports.AssocEdgeData = exports.AssocEdge = exports.loadRows = exports.loadRow = exports.loadRowX = exports.performRawQuery = exports.loadEntXViaKey = exports.loadEntViaKey = exports.loadDerivedEntX = exports.loadDerivedEnt = exports.loadEnts = exports.loadEntX = exports.loadCustomCount = exports.loadCustomEnts = exports.loadCustomData = exports.loadEnt = void 0;
+exports.setLogLevels = exports.loadConfig = exports.LoggedOutViewer = exports.IDViewer = exports.ContextCache = exports.query = exports.AllowIfViewerHasIdentityPrivacyPolicy = exports.AllowIfViewerPrivacyPolicy = exports.AllowIfSubPolicyAllowsRule = exports.AllowIfConditionAppliesRule = exports.AlwaysDenyPrivacyPolicy = exports.AlwaysAllowPrivacyPolicy = exports.applyPrivacyPolicyX = exports.applyPrivacyPolicy = exports.DelayedResultRule = exports.DenyIfEntIsVisiblePolicy = exports.AllowIfEntIsVisiblePolicy = exports.DenyIfEntIsNotVisibleRule = exports.DenyIfEntIsVisibleRule = exports.AllowIfEntIsNotVisibleRule = exports.AllowIfEntIsVisibleRule = exports.DenyIfViewerOutboundEdgeDoesNotExistRule = exports.DenyIfViewerInboundEdgeDoesNotExistRule = exports.DenyIfEdgeDoesNotExistRule = exports.DenyIfViewerOutboundEdgeExistsRule = void 0;
 __exportStar(require("./core/base"), exports);
 var ent_1 = require("./core/ent");
 Object.defineProperty(exports, "loadEnt", { enumerable: true, get: function () { return ent_1.loadEnt; } });
 Object.defineProperty(exports, "loadCustomData", { enumerable: true, get: function () { return ent_1.loadCustomData; } });
 Object.defineProperty(exports, "loadCustomEnts", { enumerable: true, get: function () { return ent_1.loadCustomEnts; } });
+Object.defineProperty(exports, "loadCustomCount", { enumerable: true, get: function () { return ent_1.loadCustomCount; } });
 Object.defineProperty(exports, "loadEntX", { enumerable: true, get: function () { return ent_1.loadEntX; } });
 Object.defineProperty(exports, "loadEnts", { enumerable: true, get: function () { return ent_1.loadEnts; } });
 Object.defineProperty(exports, "loadDerivedEnt", { enumerable: true, get: function () { return ent_1.loadDerivedEnt; } });
@@ -43,9 +48,6 @@ Object.defineProperty(exports, "performRawQuery", { enumerable: true, get: funct
 Object.defineProperty(exports, "loadRowX", { enumerable: true, get: function () { return ent_1.loadRowX; } });
 Object.defineProperty(exports, "loadRow", { enumerable: true, get: function () { return ent_1.loadRow; } });
 Object.defineProperty(exports, "loadRows", { enumerable: true, get: function () { return ent_1.loadRows; } });
-Object.defineProperty(exports, "EditNodeOperation", { enumerable: true, get: function () { return ent_1.EditNodeOperation; } });
-Object.defineProperty(exports, "EdgeOperation", { enumerable: true, get: function () { return ent_1.EdgeOperation; } });
-Object.defineProperty(exports, "DeleteNodeOperation", { enumerable: true, get: function () { return ent_1.DeleteNodeOperation; } });
 Object.defineProperty(exports, "AssocEdge", { enumerable: true, get: function () { return ent_1.AssocEdge; } });
 Object.defineProperty(exports, "AssocEdgeData", { enumerable: true, get: function () { return ent_1.AssocEdgeData; } });
 Object.defineProperty(exports, "loadEdgeData", { enumerable: true, get: function () { return ent_1.loadEdgeData; } });
@@ -57,6 +59,14 @@ 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; } });
+// TODO should these even be exported from the root?
+var operations_1 = require("./action/operations");
+Object.defineProperty(exports, "EditNodeOperation", { enumerable: true, get: function () { return operations_1.EditNodeOperation; } });
+Object.defineProperty(exports, "RawQueryOperation", { enumerable: true, get: function () { return operations_1.RawQueryOperation; } });
+Object.defineProperty(exports, "EdgeOperation", { enumerable: true, get: function () { return operations_1.EdgeOperation; } });
+Object.defineProperty(exports, "DeleteNodeOperation", { enumerable: true, get: function () { return operations_1.DeleteNodeOperation; } });
+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);
@@ -101,6 +111,7 @@ Object.defineProperty(exports, "AllowIfSubPolicyAllowsRule", { enumerable: true,
 Object.defineProperty(exports, "AllowIfViewerPrivacyPolicy", { enumerable: true, get: function () { return privacy_1.AllowIfViewerPrivacyPolicy; } });
 Object.defineProperty(exports, "AllowIfViewerHasIdentityPrivacyPolicy", { enumerable: true, get: function () { return privacy_1.AllowIfViewerHasIdentityPrivacyPolicy; } });
 __exportStar(require("./core/query"), exports);
+__exportStar(require("./core/query_impl"), exports);
 __exportStar(require("./schema/"), exports);
 const q = __importStar(require("./core/clause"));
 const query = {
@@ -109,17 +120,31 @@ const query = {
     And: q.And,
     AndOptional: q.AndOptional,
     Or: q.Or,
+    OrOptional: q.OrOptional,
     In: q.In,
+    UuidIn: q.UuidIn,
+    IntegerIn: q.IntegerIn,
+    TextIn: q.TextIn,
+    DBTypeIn: q.DBTypeIn,
+    UuidNotIn: q.UuidNotIn,
+    IntegerNotIn: q.IntegerNotIn,
+    TextNotIn: q.TextNotIn,
+    DBTypeNotIn: q.DBTypeNotIn,
     Greater: q.Greater,
     Less: q.Less,
     GreaterEq: q.GreaterEq,
     LessEq: q.LessEq,
     ArrayEq: q.ArrayEq,
     ArrayNotEq: q.ArrayNotEq,
-    ArrayGreater: q.ArrayGreater,
-    ArrayLess: q.ArrayLess,
-    ArrayGreaterEq: q.ArrayGreaterEq,
-    ArrayLessEq: q.ArrayLessEq,
+    PostgresArrayContainsValue: q.PostgresArrayContainsValue,
+    PostgresArrayContains: q.PostgresArrayContains,
+    PostgresArrayNotContainsValue: q.PostgresArrayNotContainsValue,
+    PostgresArrayNotContains: q.PostgresArrayNotContains,
+    PostgresArrayOverlaps: q.PostgresArrayOverlaps,
+    PostgresArrayNotOverlaps: q.PostgresArrayNotOverlaps,
+    JSONPathValuePredicate: q.JSONPathValuePredicate,
+    JSONObjectFieldKeyASJSON: q.JSONObjectFieldKeyASJSON,
+    JSONObjectFieldKeyAsText: q.JSONObjectFieldKeyAsText,
     TsQuery: q.TsQuery,
     PlainToTsQuery: q.PlainToTsQuery,
     PhraseToTsQuery: q.PhraseToTsQuery,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snowtop/ent",
-  "version": "0.1.0-alpha16",
+  "version": "0.1.0-alpha160-test2",
   "description": "snowtop ent framework",
   "main": "index.js",
   "types": "index.d.ts",
@@ -8,29 +8,30 @@
     "example": "examples"
   },
   "dependencies": {
-    "@types/node": "^15.0.2",
+    "@types/node": "^20.2.5",
     "camel-case": "^4.1.2",
-    "dataloader": "^2.0.0",
-    "glob": "^7.1.6",
-    "graph-data-structure": "^1.12.0",
+    "cosmiconfig": "^8.1.3",
+    "dataloader": "^2.2.2",
+    "glob": "^10.2.6",
+    "graph-data-structure": "^3.3.0",
     "js-yaml": "^4.1.0",
-    "json5": "^2.1.3",
-    "luxon": "^1.25.0",
+    "json5": "^2.2.3",
+    "luxon": "^3.3.0",
     "memoizee": "^0.4.15",
-    "minimist": "^1.2.6",
+    "minimist": "^1.2.8",
     "pascal-case": "^3.1.2",
-    "pg": "^8.0.3",
-    "prettier": "^2.3.2",
-    "reflect-metadata": "^0.1.13",
-    "snake-case": "^3.0.3",
-    "ts-node": "^10.2.1",
-    "tsconfig-paths": "^3.11.0",
-    "tslib": "^2.3.1",
-    "typescript": "^4.4.2",
-    "uuid": "^8.3.2"
+    "patch-package": "^7.0.0",
+    "pg": "^8.11.0",
+    "prettier": "^2.8.8",
+    "snake-case": "^3.0.4",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "tslib": "^2.5.2",
+    "typescript": "^5.0.4",
+    "uuid": "^9.0.0"
   },
   "peerDependencies": {
-    "better-sqlite3": "^7.4.1",
+    "better-sqlite3": "^8.4.0",
     "graphql": "^16.5.0"
   },
   "peerDependenciesMeta": {
@@ -39,7 +40,7 @@
     }
   },
   "engines": {
-    "node": ">=14.0"
+    "node": ">=16.0"
   },
   "devDependencies": {},
   "scripts": {},

package/parse_schema/parse.d.ts

@@ -1,24 +1,26 @@
 import { Schema, Field, AssocEdge, AssocEdgeGroup, Action } from "../schema";
-import { ActionField, Type } from "../schema/schema";
+import { ActionField, Type, FieldMap, GlobalSchema, TransformReadBetaResult, CanViewerDo } from "../schema/schema";
+export declare function processFields(src: FieldMap | Field[], patternName?: string): Promise<ProcessedField[]>;
 declare enum NullableResult {
     CONTENTS = "contents",
     CONTENTS_AND_LIST = "contentsAndList",
     ITEM = "true"
 }
-declare type ProcessedActionField = Omit<ActionField, "nullable"> & {
+type ProcessedActionField = Omit<ActionField, "nullable"> & {
     nullable?: NullableResult;
 };
-declare type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActions"> & {
+type ProcessedAssocEdge = Omit<AssocEdge, "actionOnlyFields" | "edgeActions"> & {
     patternName?: string;
     edgeActions?: OutputAction[];
 };
 interface TransformFlags {
     transformsSelect?: boolean;
     transformsDelete?: boolean;
+    transformsLoaderCodegen?: TransformReadBetaResult;
     transformsInsert?: boolean;
     transformsUpdate?: boolean;
 }
-declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & TransformFlags & {
+type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & TransformFlags & {
     actions: OutputAction[];
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
@@ -26,11 +28,12 @@ declare type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" |
     schemaPath?: string;
     patternNames?: string[];
 };
-declare type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
+type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
 };
-declare type OutputAction = Omit<Action, "actionOnlyFields"> & {
+type OutputAction = Omit<Action, "actionOnlyFields" | "canViewerDo"> & {
     actionOnlyFields?: ProcessedActionField[];
+    canViewerDo?: CanViewerDo;
 };
 interface schemasDict {
     [key: string]: ProcessedSchema;
@@ -41,19 +44,21 @@ interface ProcessedPattern {
     fields: ProcessedField[];
     disableMixin?: boolean;
 }
-declare type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
+type ProcessedType = Omit<Type, "subFields" | "listElemType" | "unionFields"> & {
     subFields?: ProcessedField[];
     listElemType?: ProcessedType;
     unionFields?: ProcessedField[];
 };
-declare type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy" | "type"> & {
+export type ProcessedField = Omit<Field, "defaultValueOnEdit" | "defaultValueOnCreate" | "privacyPolicy" | "type" | "serverDefault"> & {
     name: string;
     hasDefaultValueOnCreate?: boolean;
     hasDefaultValueOnEdit?: boolean;
     patternName?: string;
     hasFieldPrivacy?: boolean;
+    hasEditFieldPrivacy?: boolean;
     derivedFields?: ProcessedField[];
     type: ProcessedType;
+    serverDefault?: string;
 };
 interface patternsDict {
     [key: string]: ProcessedPattern;
@@ -61,9 +66,28 @@ interface patternsDict {
 interface Result {
     schemas: schemasDict;
     patterns: patternsDict;
+    globalSchema?: ProcessedGlobalSchema;
+    config?: {
+        rome?: RomeConfig;
+    };
 }
 declare type PotentialSchemas = {
     [key: string]: any;
 };
-export declare function parseSchema(potentialSchemas: PotentialSchemas): Result;
+export declare function parseSchema(potentialSchemas: PotentialSchemas, globalSchema?: GlobalSchema): Promise<Result>;
+interface RomeConfig {
+    indentStyle?: string;
+    lineWidth?: number;
+    indentSize?: number;
+    quoteStyle?: string;
+    quoteProperties?: string;
+    trailingComma?: string;
+}
+interface ProcessedGlobalSchema {
+    globalEdges: ProcessedAssocEdge[];
+    extraEdgeFields: ProcessedField[];
+    init?: boolean;
+    transformsEdges?: boolean;
+    globalFields?: ProcessedField[];
+}
 export {};

package/parse_schema/parse.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchema = void 0;
-function processFields(src, patternName) {
+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 = {};
     if (Array.isArray(src)) {
@@ -19,10 +22,11 @@ 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
@@ -36,6 +40,19 @@ function processFields(src, patternName) {
         else {
             delete f.polymorphic;
         }
+        if (field.private) {
+            // convert boolean into object
+            // we keep boolean as an option to keep API simple
+            if (typeof field.private === "boolean") {
+                f.private = {};
+            }
+            else {
+                f.private = field.private;
+            }
+        }
+        else {
+            delete f.private;
+        }
         // convert string to object to make API consumed by go simple
         if (f.fieldEdge && f.fieldEdge.inverseEdge) {
             if (typeof f.fieldEdge.inverseEdge === "string") {
@@ -47,26 +64,49 @@ function processFields(src, patternName) {
         if (patternName) {
             f.patternName = patternName;
         }
+        if (field.serverDefault !== undefined) {
+            f.serverDefault = await transformServerDefault(name, field, field.serverDefault);
+        }
         transformType(field.type);
         if (field.getDerivedFields) {
-            f.derivedFields = processFields(field.getDerivedFields(name));
+            f.derivedFields = await processFields(field.getDerivedFields(name));
         }
         if (field.type.subFields) {
-            f.type.subFields = processFields(field.type.subFields);
+            f.type.subFields = await processFields(field.type.subFields);
         }
         if (field.type.unionFields) {
-            f.type.unionFields = processFields(field.type.unionFields);
+            f.type.unionFields = await processFields(field.type.unionFields);
         }
         if (field.type.listElemType &&
             field.type.listElemType.subFields &&
             // check to avoid ts-ignore below. exists just for tsc
             f.type.listElemType) {
-            f.type.listElemType.subFields = processFields(field.type.listElemType.subFields);
+            f.type.listElemType.subFields = await processFields(field.type.listElemType.subFields);
         }
         ret.push(f);
     }
     return ret;
 }
+exports.processFields = processFields;
+async function transformServerDefault(name, f, value) {
+    if (f.valid) {
+        if (!(await f.valid(value))) {
+            throw new Error(`invalid value ${value} passed to field ${name}`);
+        }
+    }
+    if (f.format) {
+        value = await f.format(value);
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "number":
+        case "bigint":
+        case "string":
+            return `${value}`;
+        default:
+            throw new Error(`invalid value ${value} passed to field ${name}`);
+    }
+}
 function transformImportType(typ) {
     if (!typ.importType) {
         return;
@@ -108,12 +148,12 @@ function processEdgeGroups(processedSchema, edgeGroups) {
         processedSchema.assocEdgeGroups.push(group2);
     }
 }
-function processPattern(patterns, pattern, processedSchema) {
+async function processPattern(patterns, pattern, processedSchema) {
     let ret = {
         ...pattern,
     };
     const name = pattern.name;
-    const fields = processFields(pattern.fields, pattern.name);
+    const fields = await processFields(pattern.fields, pattern.name);
     processedSchema.fields.push(...fields);
     if (pattern.edges) {
         const edges = processEdges(pattern.edges, pattern.name);
@@ -122,6 +162,23 @@ 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
@@ -146,35 +203,51 @@ 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;
 }
-function parseSchema(potentialSchemas) {
+async function parseSchema(potentialSchemas, globalSchema) {
     let schemas = {};
     let patterns = {};
+    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];
         let schema;
@@ -190,6 +263,7 @@ function parseSchema(potentialSchemas) {
         }
         let processedSchema = {
             fields: [],
+            fieldOverrides: schema.fieldOverrides,
             schemaPath: schema.schemaPath,
             tableName: schema.tableName,
             enumTable: schema.enumTable,
@@ -200,19 +274,27 @@ function parseSchema(potentialSchemas) {
             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
         // ¯\_(ツ)_/¯
         let patternNames = [];
         if (schema.patterns) {
             for (const pattern of schema.patterns) {
-                const ret = processPattern(patterns, pattern, processedSchema);
+                const ret = await processPattern(patterns, pattern, processedSchema);
                 patternNames.push(pattern.name);
                 if (ret.transformsSelect) {
                     if (processedSchema.transformsSelect) {
                         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) {
@@ -222,7 +304,7 @@ function parseSchema(potentialSchemas) {
                 }
             }
         }
-        const fields = processFields(schema.fields);
+        const fields = await processFields(schema.fields);
         processedSchema.fields.push(...fields);
         processedSchema.patternNames = patternNames;
         if (schema.edges) {
@@ -234,6 +316,73 @@ function parseSchema(potentialSchemas) {
         }
         schemas[key] = processedSchema;
     }
-    return { schemas, patterns };
+    const rome = translatePrettier();
+    return {
+        schemas,
+        patterns,
+        globalSchema: parsedGlobalSchema,
+        config: {
+            rome,
+        },
+    };
 }
 exports.parseSchema = parseSchema;
+function translatePrettier() {
+    const r = (0, cosmiconfig_1.cosmiconfigSync)("prettier").search();
+    if (!r) {
+        return;
+    }
+    const ret = {};
+    if (r.config.printWidth !== undefined) {
+        ret.lineWidth = parseInt(r.config.printWidth);
+    }
+    if (r.config.useTabs) {
+        ret.indentStyle = "tab";
+    }
+    else {
+        ret.indentStyle = "space";
+    }
+    if (r.config.tabWidth !== undefined) {
+        ret.indentSize = parseInt(r.config.tabWidth);
+    }
+    if (r.config.singleQuote) {
+        ret.quoteStyle = "single";
+    }
+    else {
+        ret.quoteStyle = "double";
+    }
+    if (r.config.quoteProps !== undefined) {
+        if (r.config.quoteProps === "consistent") {
+            // rome doesn't support this
+            ret.quoteProperties = "as-needed";
+        }
+        else {
+            ret.quoteProperties = r.config.quoteProps;
+        }
+    }
+    if (r.config.trailingComma !== undefined) {
+        ret.trailingComma = r.config.trailingComma;
+    }
+    return ret;
+}
+async function parseGlobalSchema(s) {
+    const ret = {
+        globalEdges: [],
+        extraEdgeFields: [],
+        init: !!s.extraEdgeFields ||
+            s.transformEdgeRead !== undefined ||
+            s.transformEdgeWrite !== undefined ||
+            s.fields !== undefined,
+        transformsEdges: !!s.transformEdgeRead || !!s.transformEdgeWrite,
+    };
+    if (s.extraEdgeFields) {
+        ret.extraEdgeFields = await processFields(s.extraEdgeFields);
+    }
+    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

@@ -1,11 +1,12 @@
-import { Field, FieldMap, Pattern } from "./schema";
+import { FieldMap, Pattern, FieldOverrideMap } from "./schema";
 import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
 export interface SchemaConfig extends Schema {
 }
 export declare class EntSchema implements Schema {
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    fieldOverrides: FieldOverrideMap | undefined;
     tableName: string | undefined;
     patterns: Pattern[];
     edges: Edge[] | undefined;
@@ -18,10 +19,15 @@ 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 {
-    fields: FieldMap | Field[];
+    fields: FieldMap;
+    fieldOverrides: FieldOverrideMap | undefined;
     tableName: string | undefined;
     patterns: Pattern[];
     edges: Edge[] | undefined;
@@ -34,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 {