@snowtop/ent 0.1.14 → 0.1.15

package/action/action.d.ts

@@ -24,7 +24,7 @@ export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Vie
     getInput(): Data;
     orchestrator: BuilderOrchestrator;
 }
-export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
+export interface Executor extends Iterable<DataOperation<Ent>>, Iterator<DataOperation<Ent>> {
     placeholderID: ID;
     resolveValue(val: any): Ent | null;
     builderOpChanged(builder: Builder<any>): boolean;

package/action/executor.d.ts

@@ -40,7 +40,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private executors;
     private changedOps;
     builder?: Builder<Ent> | undefined;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>, complexOptions?: ComplexExecutorOptions | undefined);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;
@@ -51,5 +51,5 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     preFetch?(queryer: Queryer, context: Context): Promise<void>;
     postFetch?(queryer: Queryer, context: Context): Promise<void>;
 }
-export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[]>;
+export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>>[]>;
 export {};

package/action/operations.d.ts

@@ -3,62 +3,62 @@ import { Viewer, Ent, ID, Data, DataOptions, EditRowOptions, LoadEntOptions, Con
 import { Executor } from "../action/action";
 import { WriteOperation, Builder } from "../action";
 import { AssocEdgeData, parameterizedQueryOptions } from "../core/ent";
-export interface UpdatedOperation {
+export interface UpdatedOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     operation: WriteOperation;
-    builder: Builder<any>;
+    builder: Builder<TEnt, TViewer>;
 }
-export interface DataOperation<T extends Ent = Ent> {
-    builder: Builder<T>;
+export interface DataOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
+    builder: Builder<TEnt, TViewer>;
     preFetch?(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     placeholderID?: ID;
     returnedRow?(): Data | null;
-    createdEnt?(viewer: Viewer): T | null;
+    createdEnt?(viewer: Viewer): TEnt | null;
     shortCircuit?(executor: Executor): boolean;
-    updatedOperation?(): UpdatedOperation | null;
+    updatedOperation?(): UpdatedOperation<TEnt, TViewer> | null;
     resolve?(executor: Executor): void;
     postFetch?(queryer: Queryer, context?: Context): Promise<void>;
 }
-export declare class DeleteNodeOperation implements DataOperation {
+export declare class DeleteNodeOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
     private id;
-    readonly builder: Builder<Ent>;
+    readonly builder: Builder<TEnt, TViewer>;
     private options;
-    constructor(id: ID, builder: Builder<Ent>, options: DataOptions);
+    constructor(id: ID, builder: Builder<TEnt, TViewer>, options: DataOptions);
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
 }
-export declare class RawQueryOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt> {
+export declare class RawQueryOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
     builder: Builder<TEnt, TViewer>;
     private queries;
     constructor(builder: Builder<TEnt, TViewer>, queries: (string | parameterizedQueryOptions)[]);
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
 }
-export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
+export interface EditNodeOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends EditRowOptions {
     fieldsToResolve: string[];
-    loadEntOptions: LoadEntOptions<T>;
+    loadEntOptions: LoadEntOptions<TEnt>;
     key: string;
     onConflict?: CreateRowOptions["onConflict"];
-    builder: Builder<T>;
+    builder: Builder<TEnt, TViewer>;
 }
-export declare class NoOperation<T extends Ent> implements DataOperation<T> {
-    builder: Builder<any>;
+export declare class NoOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
+    builder: Builder<TEnt, TViewer>;
     private row;
-    constructor(builder: Builder<any>, existingEnt?: Ent | null);
+    constructor(builder: Builder<TEnt, TViewer>, existingEnt?: Ent | null);
     performWrite(queryer: Queryer, context?: Context): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     returnedRow(): Data | null;
 }
-export declare class EditNodeOperation<T extends Ent> implements DataOperation {
-    options: EditNodeOptions<T>;
+export declare class EditNodeOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
+    options: EditNodeOptions<TEnt, TViewer>;
     private existingEnt;
     private row;
     placeholderID?: ID | undefined;
     private updatedOp;
-    builder: Builder<T>;
+    builder: Builder<TEnt, TViewer>;
     private resolved;
-    constructor(options: EditNodeOptions<T>, existingEnt?: Ent | null);
+    constructor(options: EditNodeOptions<TEnt, TViewer>, existingEnt?: Ent | null);
     resolve<T extends Ent>(executor: Executor): void;
     private hasData;
     private buildOnConflictQuery;
@@ -67,8 +67,8 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     private reloadRow;
     performWriteSync(queryer: SyncQueryer, context?: Context): void;
     returnedRow(): Data | null;
-    createdEnt(viewer: Viewer): T | null;
-    updatedOperation(): UpdatedOperation | null;
+    createdEnt(viewer: Viewer): TEnt | null;
+    updatedOperation(): UpdatedOperation<TEnt, TViewer> | null;
 }
 export interface AssocEdgeInputOptions extends AssocEdgeOptions {
     time?: Date;
@@ -85,8 +85,8 @@ export interface AssocEdgeInput extends AssocEdgeInputOptions {
     id2: ID;
     id2Type: string;
 }
-export declare class EdgeOperation implements DataOperation {
-    builder: Builder<any>;
+export declare class EdgeOperation<TViewer extends Viewer = Viewer> implements DataOperation<any, TViewer> {
+    builder: Builder<any, TViewer>;
     edgeInput: AssocEdgeInput;
     private options;
     private edgeData;
@@ -102,33 +102,33 @@ export declare class EdgeOperation implements DataOperation {
     private performInsertWriteSync;
     private resolveImpl;
     resolve(executor: Executor): void;
-    symmetricEdge(): EdgeOperation;
-    inverseEdge(edgeData: AssocEdgeData): EdgeOperation;
+    symmetricEdge(): EdgeOperation<TViewer>;
+    inverseEdge(edgeData: AssocEdgeData): EdgeOperation<TViewer>;
     private static resolveIDs;
     private static isBuilder;
     private static resolveData;
-    static inboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id1: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static outboundEdge<T extends Ent, T2 extends Ent>(builder: Builder<T>, edgeType: string, id2: Builder<T2> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeInboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): EdgeOperation;
-    static removeOutboundEdge<T extends Ent>(builder: Builder<T>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): EdgeOperation;
+    static inboundEdge<T extends Ent<TViewer>, T2 extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id1: Builder<T2, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
+    static outboundEdge<T extends Ent<TViewer>, T2 extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id2: Builder<T2, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
+    static removeInboundEdge<T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
+    static removeOutboundEdge<T extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<T, TViewer>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): EdgeOperation<TViewer>;
 }
-export declare class ConditionalOperation<T extends Ent = Ent> implements DataOperation<T> {
-    protected op: DataOperation<T>;
+export declare class ConditionalOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements DataOperation<TEnt, TViewer> {
+    protected op: DataOperation<TEnt, TViewer>;
     private conditionalBuilder;
     placeholderID?: ID | undefined;
     protected shortCircuited: boolean;
-    readonly builder: Builder<T>;
-    constructor(op: DataOperation<T>, conditionalBuilder: Builder<any>);
+    readonly builder: Builder<TEnt, TViewer>;
+    constructor(op: DataOperation<TEnt, TViewer>, conditionalBuilder: Builder<TEnt, TViewer>);
     shortCircuit(executor: Executor): boolean;
     preFetch(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
     performWriteSync(queryer: SyncQueryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): void;
     performWrite(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
     returnedRow(): Data | null;
-    updatedOperation(): UpdatedOperation | null;
+    updatedOperation(): UpdatedOperation<TEnt, TViewer> | null;
     resolve(executor: Executor): void;
     postFetch(queryer: Queryer, context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined): Promise<void>;
 }
-export declare class ConditionalNodeOperation<T extends Ent> extends ConditionalOperation<T> {
-    createdEnt(viewer: Viewer): T | null;
-    updatedOperation(): UpdatedOperation | null;
+export declare class ConditionalNodeOperation<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> extends ConditionalOperation<TEnt, TViewer> {
+    createdEnt(viewer: Viewer): TEnt | null;
+    updatedOperation(): UpdatedOperation<TEnt, TViewer> | null;
 }

package/action/orchestrator.d.ts

@@ -21,14 +21,14 @@ export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends D
     expressions?: Map<string, clause.Clause>;
     fieldInfo: FieldInfoMap;
 }
-interface edgeInputDataOpts {
+interface edgeInputDataOpts<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> {
     edgeType: string;
-    id: Builder<Ent> | ID;
+    id: Builder<TEnt, TViewer> | ID;
     nodeType?: string;
     options?: AssocEdgeInputOptions;
 }
-export interface EdgeInputData extends edgeInputDataOpts {
-    isBuilder(id: Builder<Ent> | ID): id is Builder<Ent>;
+export interface EdgeInputData<TViewer extends Viewer = Viewer> extends edgeInputDataOpts<any, TViewer> {
+    isBuilder(id: Builder<any, TViewer> | ID): id is Builder<any, TViewer>;
 }
 export declare enum edgeDirection {
     inboundEdge = 0,
@@ -62,7 +62,7 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeInboundEdge(id1: ID, edgeType: string, options?: AssocEdgeOptions): void;
     removeOutboundEdge(id2: ID, edgeType: string, options?: AssocEdgeOptions): void;
-    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData[];
+    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData<TViewer>[];
     clearInputEdges(edgeType: string, op: WriteOperation, id?: ID): void;
     private buildMainOp;
     private getEdgeOperation;
@@ -108,24 +108,24 @@ export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
 }
-export declare class EntChangeset<T extends Ent> implements Changeset {
+export declare class EntChangeset<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer> implements Changeset {
     viewer: Viewer;
     private builder;
     readonly placeholderID: ID;
     private conditionalOverride;
-    operations: DataOperation[];
+    operations: DataOperation<any, TViewer>[];
     dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined;
     changesets?: Changeset[] | undefined;
     private options?;
     private _executor;
-    constructor(viewer: Viewer, builder: Builder<T>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
-    static changesetFrom(builder: Builder<any, any, any>, ops: DataOperation[]): EntChangeset<any>;
-    static changesetFromQueries(builder: Builder<any, any, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any>;
+    constructor(viewer: Viewer, builder: Builder<TEnt, TViewer>, placeholderID: ID, conditionalOverride: boolean, operations: DataOperation<any, TViewer>[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<TEnt, Data, TViewer, MaybeNull<TEnt>> | undefined);
+    static changesetFrom<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, ops: DataOperation<any, TViewer>[]): EntChangeset<any, TViewer>;
+    static changesetFromQueries<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, queries: Array<string | parameterizedQueryOptions>): EntChangeset<any, TViewer>;
     private static changesetFromEdgeOp;
-    static changesetFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
-    static changesetFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: Builder<any> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
-    static changesetRemoveFromOutboundEdge(builder: Builder<any, any, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
-    static changesetRemoveFromInboundEdge(builder: Builder<any, any, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any>>;
+    static changesetFromOutboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id2: Builder<any, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetFromInboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id1: Builder<any, TViewer> | ID, nodeType: string, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetRemoveFromOutboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id2: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
+    static changesetRemoveFromInboundEdge<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer>(builder: Builder<TEnt, TViewer, any>, edgeType: string, id1: ID, options?: AssocEdgeInputOptions): Promise<EntChangeset<any, TViewer>>;
     executor(): Executor;
 }
 export {};

package/action/transaction.d.ts

@@ -1,10 +1,13 @@
-import { Ent, Viewer } from "../core/base";
-import { Action, Builder } from "./action";
-type ActionAny<TViewer extends Viewer = Viewer> = Action<Ent<TViewer>, Builder<Ent<TViewer>, TViewer, any>, Viewer<any, any>, any, any>;
+import { Ent, Viewer, Data } from "../core/base";
+import { Action } from "./action";
+import { EntBuilder } from "./experimental_action";
+type MaybeNull<T extends Ent> = T | null;
+type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+type ActionAny<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> = Action<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>;
 export declare class Transaction<TViewer extends Viewer = Viewer> {
     private viewer;
     private actions;
-    constructor(viewer: TViewer, actions: ActionAny<TViewer>[]);
+    constructor(viewer: TViewer, actions: ActionAny<any, TViewer, Data>[]);
     run(): Promise<void>;
 }
 export {};

package/core/convert.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export declare function convertDate(val: any): Date;
 export declare function convertNullableDate(val: any): Date | null;
 export declare function convertBool(val: any): boolean;
@@ -12,3 +13,5 @@ export declare function convertJSON(val: any): any;
 export declare function convertNullableJSON(val: any): any | null;
 export declare function convertJSONList(val: any): any[];
 export declare function convertNullableJSONList(val: any): any[] | null;
+export declare function convertTextToBuffer(val: any): Buffer;
+export declare function convertNullableTextToBuffer(val: any): Buffer;

package/core/convert.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertNullableJSONList = exports.convertJSONList = exports.convertNullableJSON = exports.convertJSON = exports.convertNullableBoolList = exports.convertBoolList = exports.convertNullableDateList = exports.convertDateList = exports.convertNullableList = exports.convertList = exports.convertNullableBool = exports.convertBool = exports.convertNullableDate = exports.convertDate = void 0;
+exports.convertNullableTextToBuffer = exports.convertTextToBuffer = exports.convertNullableJSONList = exports.convertJSONList = exports.convertNullableJSON = exports.convertJSON = exports.convertNullableBoolList = exports.convertBoolList = exports.convertNullableDateList = exports.convertDateList = exports.convertNullableList = exports.convertList = exports.convertNullableBool = exports.convertBool = exports.convertNullableDate = exports.convertDate = void 0;
 const luxon_1 = require("luxon");
 // these are needed to deal with SQLite having different types stored in the db vs the representation
 // gotten back from the db/needed in ent land
@@ -104,3 +104,17 @@ function convertNullableJSONList(val) {
     return convertNullableList(val, convertJSON);
 }
 exports.convertNullableJSONList = convertNullableJSONList;
+function convertTextToBuffer(val) {
+    if (typeof val === "string") {
+        return Buffer.from(val, "base64");
+    }
+    return val;
+}
+exports.convertTextToBuffer = convertTextToBuffer;
+function convertNullableTextToBuffer(val) {
+    if (val == null) {
+        return val;
+    }
+    return convertTextToBuffer(val);
+}
+exports.convertNullableTextToBuffer = convertNullableTextToBuffer;

package/package.json

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

package/schema/binary_field.d.ts

@@ -0,0 +1,14 @@
+import { BaseField } from "./field";
+import { Type, Field, FieldOptions } from "./schema";
+export declare class ByteaField extends BaseField implements Field {
+    type: Type;
+    format(val: any): any;
+    valid(val: any): boolean;
+}
+export declare function ByteaType(options?: FieldOptions): ByteaField & FieldOptions;
+export declare class BinaryTextField extends BaseField implements Field {
+    type: Type;
+    format(val: any): any;
+    valid(val: any): boolean;
+}
+export declare function BinaryTextType(options?: FieldOptions): BinaryTextField & FieldOptions;

package/schema/binary_field.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryTextType = exports.BinaryTextField = exports.ByteaType = exports.ByteaField = void 0;
+const field_1 = require("./field");
+const schema_1 = require("./schema");
+class ByteaField extends field_1.BaseField {
+    constructor() {
+        super(...arguments);
+        this.type = {
+            dbType: schema_1.DBType.Bytea,
+        };
+    }
+    format(val) {
+        return val;
+    }
+    valid(val) {
+        return val instanceof Buffer;
+    }
+}
+exports.ByteaField = ByteaField;
+/*
+ * NB: using this field requires the developer to run `npm i graphql-scalars` for the correct
+ * graphql types to be available.
+ */
+function ByteaType(options) {
+    const result = new ByteaField();
+    return Object.assign(result, options);
+}
+exports.ByteaType = ByteaType;
+class BinaryTextField extends field_1.BaseField {
+    constructor() {
+        super(...arguments);
+        this.type = {
+            dbType: schema_1.DBType.StringByte,
+        };
+    }
+    format(val) {
+        return val.toString("base64");
+    }
+    valid(val) {
+        return val instanceof Buffer;
+    }
+}
+exports.BinaryTextField = BinaryTextField;
+/*
+ * NB: using this field requires the developer to run `npm i graphql-scalars` for the correct
+ * graphql types to be available.
+ */
+function BinaryTextType(options) {
+    const result = new BinaryTextField();
+    return Object.assign(result, options);
+}
+exports.BinaryTextType = BinaryTextType;

package/schema/index.d.ts

@@ -6,3 +6,4 @@ export * from "./field";
 export * from "./json_field";
 export * from "./struct_field";
 export * from "./union_field";
+export * from "./binary_field";

package/schema/index.js

@@ -40,3 +40,4 @@ __exportStar(require("./field"), exports);
 __exportStar(require("./json_field"), exports);
 __exportStar(require("./struct_field"), exports);
 __exportStar(require("./union_field"), exports);
+__exportStar(require("./binary_field"), exports);

package/schema/schema.d.ts

@@ -153,6 +153,8 @@ export declare enum DBType {
     Date = "Date",
     Time = "Time",
     Timetz = "Timetz",
+    Bytea = "Bytea",
+    StringByte = "StringByte",
     List = "List"
 }
 export interface DeprecatedImportType {

package/schema/schema.js

@@ -39,6 +39,8 @@ var DBType;
     DBType["Date"] = "Date";
     DBType["Time"] = "Time";
     DBType["Timetz"] = "Timetz";
+    DBType["Bytea"] = "Bytea";
+    DBType["StringByte"] = "StringByte";
     DBType["List"] = "List";
 })(DBType = exports.DBType || (exports.DBType = {}));
 function isSchema(value) {

package/scripts/custom_graphql.js

@@ -363,6 +363,10 @@ async function main() {
         importPath: "graphql-type-json",
         type: "GraphQLJSON",
     }, gqlCapture);
+    (0, graphql_1.addCustomType)({
+        importPath: "graphql-scalars",
+        type: "GraphQLByte",
+    }, gqlCapture);
     const [inputsRead, _, __, imports] = await Promise.all([
         readInputs(),
         captureCustom(options.path, options.files, options.json_path, gqlCapture),

package/testutils/action/complex_schemas.d.ts

@@ -7,7 +7,7 @@ import { MockLogs } from "../../testutils/mock_log";
 import { Table } from "../db/temp_db";
 export declare function setupTest(): void;
 export declare function getML(): MockLogs;
-export declare function getOperations(): DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[];
+export declare function getOperations(): DataOperation<any, Viewer<Ent<any> | null, ID | null>>[];
 export declare const UserSchema: BuilderSchema<User>;
 export declare class UserWithBalance extends User {
 }
@@ -45,7 +45,7 @@ export declare class UserAction extends SimpleAction<User> {
     getTriggers(): Trigger<User, SimpleBuilder<User>>[];
     getObservers(): Observer<User, SimpleBuilder<User>>[];
 }
-type getMembershipFunction = (viewer: Viewer, edge: EdgeInputData) => SimpleAction<Ent>;
+type getMembershipFunction = (viewer: Viewer, edge: EdgeInputData<Viewer>) => SimpleAction<Ent>;
 export declare class GroupMembershipTrigger implements Trigger<Group, SimpleBuilder<Group>> {
     private getter;
     constructor(getter: getMembershipFunction);

package/testutils/db/temp_db.d.ts

@@ -62,6 +62,7 @@ export declare function integer(name: string, opts?: options): Column;
 export declare function float(name: string, opts?: options): Column;
 export declare function json(name: string, opts?: options): Column;
 export declare function jsonb(name: string, opts?: options): Column;
+export declare function bytea(name: string, opts?: options): Column;
 export declare function textList(name: string, opts?: options): Column;
 export declare function integerList(name: string, opts?: options): Column;
 export declare function uuidList(name: string, opts?: options): Column;

package/testutils/db/temp_db.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColumnFromField = exports.getSchemaTable = exports.doSQLiteTestFromSchemas = exports.setupPostgres = exports.setupSqlite = exports.assoc_edge_table = exports.assoc_edge_config_table = exports.TempDB = exports.enumType = exports.table = exports.boolList = exports.dateList = exports.timetzList = exports.timeList = exports.timestamptzList = exports.timestampList = exports.uuidList = exports.integerList = exports.textList = exports.jsonb = exports.json = exports.float = exports.integer = exports.bool = exports.date = exports.timetz = exports.time = exports.timestamptz = exports.timestamp = exports.enumCol = exports.text = exports.uuid = exports.index = exports.check = exports.foreignKey = exports.primaryKey = void 0;
+exports.getColumnFromField = exports.getSchemaTable = exports.doSQLiteTestFromSchemas = exports.setupPostgres = exports.setupSqlite = exports.assoc_edge_table = exports.assoc_edge_config_table = exports.TempDB = exports.enumType = exports.table = exports.boolList = exports.dateList = exports.timetzList = exports.timeList = exports.timestamptzList = exports.timestampList = exports.uuidList = exports.integerList = exports.textList = exports.bytea = exports.jsonb = exports.json = exports.float = exports.integer = exports.bool = exports.date = exports.timetz = exports.time = exports.timestamptz = exports.timestamp = exports.enumCol = exports.text = exports.uuid = exports.index = exports.check = exports.foreignKey = exports.primaryKey = void 0;
 const pg_1 = require("pg");
 const db_1 = __importStar(require("../../core/db"));
 // this should only be used in tests so we expect to be able to import without shenanigans
@@ -239,6 +239,16 @@ function jsonb(name, opts) {
     };
 }
 exports.jsonb = jsonb;
+function bytea(name, opts) {
+    return {
+        name,
+        datatype() {
+            return "BYTEA";
+        },
+        ...opts,
+    };
+}
+exports.bytea = bytea;
 function list(name, col, opts) {
     return {
         name,
@@ -724,6 +734,10 @@ function getColumnForDbType(t, dialect) {
             return jsonb;
         case schema_1.DBType.JSON:
             return json;
+        case schema_1.DBType.StringByte:
+            return text;
+        case schema_1.DBType.Bytea:
+            return bytea;
         default:
             return undefined;
     }