@snowtop/ent 0.1.11 → 0.1.13

package/parse_schema/parse.d.ts

@@ -20,13 +20,14 @@ interface TransformFlags {
     transformsInsert?: boolean;
     transformsUpdate?: boolean;
 }
-type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields"> & TransformFlags & {
+type ProcessedSchema = Omit<Schema, "edges" | "actions" | "edgeGroups" | "fields" | "defaultActionPrivacy"> & TransformFlags & {
     actions: OutputAction[];
     assocEdges: ProcessedAssocEdge[];
     assocEdgeGroups: ProcessedAssocEdgeGroup[];
     fields: ProcessedField[];
     schemaPath?: string;
     patternNames?: string[];
+    hasDefaultActionPrivacy?: boolean;
 };
 type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
     edgeAction?: OutputAction;
@@ -68,14 +69,14 @@ interface Result {
     patterns: patternsDict;
     globalSchema?: ProcessedGlobalSchema;
     config?: {
-        rome?: RomeConfig;
+        rome?: BiomeConfig;
     };
 }
 declare type PotentialSchemas = {
     [key: string]: any;
 };
 export declare function parseSchema(potentialSchemas: PotentialSchemas, globalSchema?: GlobalSchema): Promise<Result>;
-interface RomeConfig {
+interface BiomeConfig {
     indentStyle?: string;
     lineWidth?: number;
     indentSize?: number;

package/parse_schema/parse.js

@@ -278,6 +278,7 @@ async function parseSchema(potentialSchemas, globalSchema) {
             supportUpsert: schema.supportUpsert,
             showCanViewerSee: schema.showCanViewerSee,
             showCanViewerEdit: schema.showCanViewerEdit,
+            hasDefaultActionPrivacy: schema.defaultActionPrivacy !== undefined,
         };
         // let's put patterns first just so we have id, created_at, updated_at first
         // ¯\_(ツ)_/¯
@@ -316,13 +317,13 @@ async function parseSchema(potentialSchemas, globalSchema) {
         }
         schemas[key] = processedSchema;
     }
-    const rome = translatePrettier();
+    const biome = translatePrettier();
     return {
         schemas,
         patterns,
         globalSchema: parsedGlobalSchema,
         config: {
-            rome,
+            rome: biome,
         },
     };
 }
@@ -353,7 +354,7 @@ function translatePrettier() {
     }
     if (r.config.quoteProps !== undefined) {
         if (r.config.quoteProps === "consistent") {
-            // rome doesn't support this
+            // biome doesn't support this
             ret.quoteProperties = "as-needed";
         }
         else {

package/schema/base_schema.d.ts

@@ -1,5 +1,6 @@
 import { FieldMap, Pattern, FieldOverrideMap } from "./schema";
 import { Action, AssocEdgeGroup, Constraint, Edge, Index, Schema } from ".";
+import { PrivacyPolicy } from "../core/base";
 export declare const Timestamps: Pattern;
 export declare const Node: Pattern;
 export interface SchemaConfig extends Schema {
@@ -23,6 +24,7 @@ export declare class EntSchema implements Schema {
     supportUpsert?: boolean | undefined;
     showCanViewerSee?: boolean | undefined;
     showCanViewerEdit?: boolean | undefined;
+    defaultActionPrivacy?: PrivacyPolicy | (() => PrivacyPolicy);
     constructor(cfg: SchemaConfig);
 }
 export declare class EntSchemaWithTZ implements Schema {
@@ -44,6 +46,7 @@ export declare class EntSchemaWithTZ implements Schema {
     supportUpsert?: boolean | undefined;
     showCanViewerSee?: boolean | undefined;
     showCanViewerEdit?: boolean | undefined;
+    defaultActionPrivacy?: PrivacyPolicy | (() => PrivacyPolicy);
     constructor(cfg: SchemaConfig);
 }
 export declare abstract class BaseEntSchema {

package/schema/base_schema.js

@@ -93,6 +93,7 @@ class EntSchema {
         this.supportUpsert = cfg.supportUpsert;
         this.showCanViewerSee = cfg.showCanViewerSee;
         this.showCanViewerEdit = cfg.showCanViewerEdit;
+        this.defaultActionPrivacy = cfg.defaultActionPrivacy;
     }
 }
 exports.EntSchema = EntSchema;
@@ -125,6 +126,7 @@ class EntSchemaWithTZ {
         this.supportUpsert = cfg.supportUpsert;
         this.showCanViewerSee = cfg.showCanViewerSee;
         this.showCanViewerEdit = cfg.showCanViewerEdit;
+        this.defaultActionPrivacy = cfg.defaultActionPrivacy;
     }
 }
 exports.EntSchemaWithTZ = EntSchemaWithTZ;

package/schema/schema.d.ts

@@ -42,6 +42,7 @@ export default interface Schema {
     supportUpsert?: boolean;
     showCanViewerSee?: boolean;
     showCanViewerEdit?: boolean;
+    defaultActionPrivacy?: PrivacyPolicy | (() => PrivacyPolicy);
 }
 export interface AssocEdge {
     name: string;

package/schema/struct_field.d.ts

@@ -17,16 +17,18 @@ export declare class StructField extends BaseField implements Field {
     private options;
     private jsonAsList?;
     type: Type;
+    private validateUniqueKey?;
+    private checkUniqueKey;
     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;
+export declare function StructType(options: StructOptions): (StructField & structFieldOptions) | (StructField & GlobalStructOptions);
 /**
  * @deprecated use StructTypeAsList
  */
 export declare function StructListType(options: StructOptions): ListField;
-export declare function StructTypeAsList(options: StructOptions): StructField & StructOptions;
+export declare function StructTypeAsList(options: StructOptions): (StructField & structFieldOptions) | (StructField & GlobalStructOptions);
 export {};

package/schema/struct_field.js

@@ -26,6 +26,10 @@ class StructField extends field_1.BaseField {
                 dbType: schema_1.DBType.JSONB,
             };
         }
+        if (options.validateUniqueKey) {
+            this.validateUniqueKey = options.validateUniqueKey;
+            this.checkUniqueKey = true;
+        }
     }
     formatImpl(obj, nested) {
         if (!(obj instanceof Object)) {
@@ -113,9 +117,27 @@ class StructField extends field_1.BaseField {
             let dbKey = (0, schema_1.getStorageKey)(field, k);
             let camelKey = (0, camel_case_1.camelCase)(k);
             let val = obj[camelKey];
+            let uniqueKeyField = false;
+            if (this.validateUniqueKey !== undefined &&
+                (camelKey === this.validateUniqueKey ||
+                    k === this.validateUniqueKey ||
+                    dbKey === this.validateUniqueKey)) {
+                // this.validateUniqueKey = camelKey;
+                uniqueKeyField = true;
+            }
+            if (uniqueKeyField && this.checkUniqueKey) {
+                this.validateUniqueKey = camelKey;
+            }
             if (val === undefined && obj[dbKey] !== undefined) {
+                if (uniqueKeyField && this.checkUniqueKey) {
+                    this.validateUniqueKey = dbKey;
+                }
                 val = obj[dbKey];
             }
+            // we've processed this once and no need to process this again
+            if (uniqueKeyField && this.checkUniqueKey) {
+                this.checkUniqueKey = false;
+            }
             if (val === undefined || val === null) {
                 // nullable, nothing to do here
                 if (field.nullable) {
@@ -168,16 +190,23 @@ class StructField extends field_1.BaseField {
             if (!Array.isArray(obj)) {
                 return false;
             }
+            // hmm shared instance across tests means this is needed.
+            // are there other places that have an issue like this???
+            this.checkUniqueKey = true;
             const unique = new Set();
-            const valid = await Promise.all(obj.map((v) => {
-                if (this.options.validateUniqueKey) {
-                    const value = v[this.options.validateUniqueKey];
+            const valid = await Promise.all(obj.map(async (v) => {
+                const valid = await this.validImpl(v);
+                if (!valid) {
+                    return false;
+                }
+                if (this.validateUniqueKey) {
+                    let value = v[this.validateUniqueKey];
                     if (unique.has(value)) {
                         return false;
                     }
                     unique.add(value);
                 }
-                return this.validImpl(v);
+                return true;
             }));
             return valid.every((b) => b);
         }

package/scripts/custom_graphql.js

@@ -43,7 +43,7 @@ const const_1 = require("../core/const");
 // life is hard
 const MODULE_PATH = const_1.GRAPHQL_PATH;
 async function readInputs() {
-    return await new Promise((resolve) => {
+    return new Promise((resolve) => {
         const rl = readline.createInterface({
             input: process.stdin,
             //  output: process.stdout,

package/testutils/builder.d.ts

@@ -4,7 +4,7 @@ import { Action, Builder, Changeset, WriteOperation, Validator, Trigger, Observe
 import { FieldMap, Schema } from "../schema";
 import { SchemaConfig, EntSchema } from "../schema/base_schema";
 import { FieldInfoMap } from "../schema/schema";
-import { Clause } from "src/core/clause";
+import { Clause } from "../core/clause";
 import { ChangesetOptions } from "../action/action";
 export declare class BaseEnt {
     viewer: Viewer;

package/testutils/builder.js

@@ -248,10 +248,10 @@ class SimpleBuilder {
         return this.orchestrator.buildWithOptions_BETA(options);
     }
     async editedEnt() {
-        return await this.orchestrator.editedEnt();
+        return this.orchestrator.editedEnt();
     }
     async editedEntX() {
-        return await this.orchestrator.editedEntX();
+        return this.orchestrator.editedEntX();
     }
     async save() {
         await (0, action_1.saveBuilder)(this);
@@ -260,10 +260,10 @@ class SimpleBuilder {
         await (0, action_1.saveBuilderX)(this);
     }
     async valid() {
-        return await this.orchestrator.valid();
+        return this.orchestrator.valid();
     }
     async validX() {
-        return await this.orchestrator.validX();
+        return this.orchestrator.validX();
     }
 }
 exports.SimpleBuilder = SimpleBuilder;

package/testutils/ent-graphql-tests/index.js

@@ -275,7 +275,7 @@ function expectQueryResult(schema, fieldType, ...options) {
 }
 async function expectQueryFromRoot(config, ...options // TODO queries? expected values
 ) {
-    return await expectFromRoot({
+    return expectFromRoot({
         ...config,
         queryPrefix: "query",
         querySuffix: "Query",
@@ -292,7 +292,7 @@ async function expectMutation(config, ...options) {
             input: args,
         };
     }
-    return await expectFromRoot({
+    return expectFromRoot({
         ...config,
         args: args,
         root: config.mutation,

package/testutils/fake_data/fake_contact.js

@@ -89,7 +89,7 @@ function getContactBuilder(viewer, input) {
 exports.getContactBuilder = getContactBuilder;
 async function createContact(viewer, input) {
     const builder = getContactBuilder(viewer, input);
-    return await builder.saveX();
+    return builder.saveX();
 }
 exports.createContact = createContact;
 exports.contactLoader = new loaders_1.ObjectLoaderFactory({

package/testutils/fake_data/fake_event.js

@@ -93,6 +93,6 @@ function getEventBuilder(viewer, input) {
 exports.getEventBuilder = getEventBuilder;
 async function createEvent(viewer, input) {
     const builder = getEventBuilder(viewer, input);
-    return await builder.saveX();
+    return builder.saveX();
 }
 exports.createEvent = createEvent;

package/testutils/fake_data/test_helpers.js

@@ -110,7 +110,7 @@ async function createAllContacts(opts) {
             time: new Date(), // set time to advanceBy time
         });
         await builder.saveX();
-        return await builder.editedEntX();
+        return builder.editedEntX();
     }));
     expect(contacts.length).toBe(userInputs.length);
     return [userr, contacts];
@@ -221,7 +221,7 @@ async function createTestEvent(user, input) {
     });
     builder.orchestrator.addOutboundEdge(user.id, _1.EdgeType.EventToHosts, "User");
     await builder.saveX();
-    return await builder.editedEntX();
+    return builder.editedEntX();
 }
 exports.createTestEvent = createTestEvent;
 async function setupTempDB(global = false) {

package/testutils/fake_data/user_query.js

@@ -158,7 +158,7 @@ class CustomEdge extends ent_1.AssocEdge {
         this.deleted_at = data.deleted_at;
     }
     async loadUser(viewer) {
-        return await internal_1.FakeUser.load(viewer, this.id2);
+        return internal_1.FakeUser.load(viewer, this.id2);
     }
 }
 exports.CustomEdge = CustomEdge;

package/testutils/query.d.ts

@@ -0,0 +1,9 @@
+import { Data, Ent, Viewer } from "../core/base";
+import { FakeUser } from "./fake_data";
+import { EdgeQuery } from "../core/query";
+import { MockLogs } from "./mock_log";
+export declare function getVerifyAfterEachCursorGeneric<TSource extends Ent<Viewer>, TDest extends Ent<Viewer>, TData extends Data>(edges: TData[], pageLength: number, user: FakeUser, getQuery: () => EdgeQuery<TSource, TDest, TData>, ml: MockLogs, verifyQuery?: (query: EdgeQuery<TSource, TDest, TData>, cursor: string | undefined) => void): {
+    verify: (i: number, hasEdge: boolean, hasNextPage: boolean | undefined, cursor?: string) => Promise<void>;
+    getCursor: (edge: TData) => string;
+};
+export declare function getWhereClause(query: any): any;

package/testutils/query.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWhereClause = exports.getVerifyAfterEachCursorGeneric = void 0;
+function getVerifyAfterEachCursorGeneric(edges, pageLength, user, getQuery, ml, verifyQuery) {
+    let query;
+    async function verify(i, hasEdge, hasNextPage, cursor) {
+        ml.clear();
+        query = getQuery();
+        const newEdges = await query.first(pageLength, cursor).queryEdges();
+        const pagination = query.paginationInfo().get(user.id);
+        if (hasEdge) {
+            expect(newEdges[0], `${i}`).toEqual(edges[i]);
+            expect(newEdges.length, `${i}`).toBe(edges.length - i >= pageLength ? pageLength : edges.length - i);
+            // verify items are the same in order
+            expect(newEdges, `${i}`).toEqual(edges.slice(i, i + newEdges.length));
+        }
+        else {
+            expect(newEdges.length, `${i}`).toBe(0);
+        }
+        if (hasNextPage) {
+            expect(pagination?.hasNextPage, `${i}`).toBe(true);
+            expect(pagination?.hasPreviousPage, `${i}`).toBe(false);
+        }
+        else {
+            expect(pagination?.hasPreviousPage, `${i}`).toBeFalsy();
+            expect(pagination?.hasNextPage, `${i}`).toBeFalsy();
+        }
+        if (verifyQuery) {
+            verifyQuery(query, cursor);
+        }
+    }
+    function getCursor(edge) {
+        return query.getCursor(edge);
+    }
+    return { verify, getCursor };
+}
+exports.getVerifyAfterEachCursorGeneric = getVerifyAfterEachCursorGeneric;
+function getWhereClause(query) {
+    const idx = query.query.indexOf("WHERE");
+    if (idx !== -1) {
+        return query.query.substr(idx + 6);
+    }
+    return null;
+}
+exports.getWhereClause = getWhereClause;

package/testutils/write.js

@@ -41,7 +41,7 @@ async function createRowForTest(options, suffix) {
         if (isSyncClient(client)) {
             return (0, ent_1.createRowSync)(client, options, suffix || "");
         }
-        return await (0, ent_1.createRow)(client, options, suffix || "");
+        return (0, ent_1.createRow)(client, options, suffix || "");
     }
     finally {
         client.release();
@@ -54,7 +54,7 @@ async function editRowForTest(options, suffix) {
         if (isSyncClient(client)) {
             return (0, ent_1.editRowSync)(client, options, suffix || "");
         }
-        return await (0, ent_1.editRow)(client, options, suffix);
+        return (0, ent_1.editRow)(client, options, suffix);
     }
     finally {
         client.release();
@@ -67,7 +67,7 @@ async function deleteRowsForTest(options, cls) {
         if (isSyncClient(client)) {
             return (0, ent_1.deleteRowsSync)(client, options, cls);
         }
-        return await (0, ent_1.deleteRows)(client, options, cls);
+        return (0, ent_1.deleteRows)(client, options, cls);
     }
     finally {
         client.release();