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

package/core/query_impl.d.ts

@@ -0,0 +1,8 @@
+export interface OrderByOption {
+    column: string;
+    direction: "ASC" | "DESC";
+    nullsPlacement?: "first" | "last";
+}
+export type OrderBy = OrderByOption[];
+export declare function getOrderByPhrase(orderby: OrderBy): string;
+export declare function reverseOrderBy(orderby: OrderBy): OrderBy;

package/core/query_impl.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseOrderBy = exports.getOrderByPhrase = void 0;
+function getOrderByPhrase(orderby) {
+    return orderby
+        .map((v) => {
+        let nullsPlacement = "";
+        switch (v.nullsPlacement) {
+            case "first":
+                nullsPlacement = " NULLS FIRST";
+                break;
+            case "last":
+                nullsPlacement = " NULLS LAST";
+                break;
+        }
+        return `${v.column} ${v.direction}${nullsPlacement}`;
+    })
+        .join(", ");
+}
+exports.getOrderByPhrase = getOrderByPhrase;
+function reverseOrderBy(orderby) {
+    return orderby.map((o) => {
+        const o2 = { ...o };
+        o2.direction = o.direction === "ASC" ? "DESC" : "ASC";
+        return o2;
+    });
+}
+exports.reverseOrderBy = reverseOrderBy;

package/core/viewer.d.ts

@@ -1,6 +1,7 @@
 import { ID, Ent, Viewer, Context } from "./base";
 export declare class LoggedOutViewer implements Viewer {
     context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined;
+    marker: string;
     constructor(context?: Context<Viewer<Ent<any> | null, ID | null>> | undefined);
     viewerID: null;
     viewer(): Promise<null>;
@@ -12,6 +13,7 @@ export interface IDViewerOptions {
     ent?: Ent | null;
 }
 export declare class IDViewer implements Viewer {
+    marker: string;
     viewerID: ID;
     private ent;
     context?: Context;

package/core/viewer.js

@@ -4,6 +4,7 @@ exports.IDViewer = exports.LoggedOutViewer = void 0;
 class LoggedOutViewer {
     constructor(context) {
         this.context = context;
+        this.marker = "loggedout";
         this.viewerID = null;
     }
     async viewer() {
@@ -16,6 +17,7 @@ class LoggedOutViewer {
 exports.LoggedOutViewer = LoggedOutViewer;
 class IDViewer {
     constructor(args, opts) {
+        this.marker = "idviewer";
         this.ent = null;
         if (typeof args === "object") {
             this.viewerID = args.viewerID;
@@ -35,7 +37,7 @@ class IDViewer {
         return this.ent;
     }
     instanceKey() {
-        return `idViewer: ${this.viewerID}`;
+        return `idViewer:${this.viewerID}`;
     }
 }
 exports.IDViewer = IDViewer;

package/graphql/graphql.d.ts

@@ -1,36 +1,112 @@
-import "reflect-metadata";
 import { GraphQLScalarType } from "graphql";
+import type { FieldMap } from "../schema";
+import { ProcessedField as ParsedProcessedField } from "../parse_schema/parse";
+import { ImportPath } from "../schema/schema";
 interface ClassType<T = any> {
     new (...args: any[]): T;
 }
-export interface CustomType {
+declare type StringToStringMap = {
+    [key: string]: string;
+};
+interface CustomFieldInput {
+    graphQLName?: string;
+    name?: string;
+    functionName?: string;
+    args?: Field[];
+    results?: Field[];
+    fieldType: CustomFieldTypeInput;
+    description?: string;
+}
+interface CustomTopLevelInput {
+    class?: string;
+    graphQLName?: string;
+    name?: string;
+    functionName?: string;
+    edgeName?: string;
+    args?: Field[];
+    results?: Field[];
+    extraImports?: ImportPath[];
+    functionContents?: string;
+    fieldType: CustomFieldTypeInput;
+    description?: string;
+    list?: boolean;
+    connection?: boolean;
+    resultType?: string;
+}
+type CustomFieldInputMap = {
+    [key: string]: CustomFieldInput[];
+};
+type CustomTypeInputMap = {
+    [key: string]: CustomTypeInput;
+};
+interface CustomObjectInput {
+    name: string;
+    graphQLName?: string;
+    fields?: CustomFieldInput[];
+}
+export interface CustomGraphQLInput {
+    fields?: CustomFieldInputMap;
+    inputs?: CustomObjectInput[];
+    objects?: CustomObjectInput[];
+    args?: CustomObjectInput[];
+    queries?: CustomTopLevelInput[];
+    mutations?: CustomTopLevelInput[];
+    customTypes?: CustomTypeInputMap;
+}
+export interface CustomTypeInput {
     type: string;
     importPath: string;
     tsType?: string;
     tsImportPath?: string;
+    enumMap?: StringToStringMap;
+    structFields?: FieldMap;
+    inputType?: boolean;
     [x: string]: any;
 }
-declare type Type = GraphQLScalarType | ClassType | string | CustomType;
-export declare type GraphQLConnection<T> = {
+export type CustomType = Omit<CustomTypeInput, "structFields"> & {
+    structFields?: ParsedProcessedField[];
+};
+type Type = GraphQLScalarType | ClassType | string | CustomTypeInput;
+export type GraphQLConnection<T> = {
     node: T;
 };
-export interface gqlFieldOptions {
+interface gqlFieldOptionsBase {
     name?: string;
     nullable?: boolean | NullableListOptions;
     description?: string;
     type?: Type | Array<Type> | GraphQLConnection<Type>;
 }
+interface gqlFieldArg extends Omit<gqlFieldOptionsBase, "name"> {
+    isContextArg?: boolean;
+    name: string;
+}
+export interface gqlFieldOptions extends gqlFieldOptionsBase {
+    class: string;
+    args?: gqlFieldArg[];
+    async?: boolean;
+    type: NonNullable<gqlFieldOptionsBase["type"]>;
+}
 export interface gqlObjectOptions {
     name?: string;
     description?: string;
 }
-declare type gqlTopLevelOptions = Exclude<gqlFieldOptions, "nullable">;
+export interface gqlObjectWithInterfaceOptions extends gqlObjectOptions {
+    interfaces?: string[];
+}
+export interface gqlObjectWithUnionOptions extends gqlObjectOptions {
+    unionTypes: string[];
+}
+type gqlMutationOptions = Omit<gqlFieldOptions, "nullable" | "type"> & {
+    type?: gqlFieldOptionsBase["type"];
+};
+type gqlQueryOptions = gqlFieldOptions;
 export declare enum CustomFieldType {
     Accessor = "ACCESSOR",
     Field = "FIELD",
     Function = "FUNCTION",
     AsyncFunction = "ASYNC_FUNCTION"
 }
+export type CustomFieldTypeInput = "ACCESSOR" | "FIELD" | "FUNCTION" | "ASYNC_FUNCTION";
 interface CustomFieldImpl {
     nodeName: string;
     gqlName: string;
@@ -42,6 +118,9 @@ interface CustomFieldImpl {
 export interface CustomField extends CustomFieldImpl {
     args: Field[];
     results: Field[];
+    extraImports?: ImportPath[];
+    functionContents?: string;
+    edgeName?: string;
 }
 export interface CustomMutation extends CustomField {
 }
@@ -51,15 +130,17 @@ export interface ProcessedCustomField extends CustomFieldImpl {
     args: ProcessedField[];
     results: ProcessedField[];
 }
-export declare type ProcessCustomFieldMap = {
-    [key: string]: ProcessedCustomField;
+export type ProcessCustomFieldMap = {
+    [key: string]: ProcessedCustomField[];
 };
 export interface CustomObject {
     nodeName: string;
     className: string;
     description?: string;
+    interfaces?: string[];
+    unionTypes?: string[];
 }
-declare type NullableListOptions = "contents" | "contentsAndList";
+type NullableListOptions = "contents" | "contentsAndList";
 interface FieldImpl {
     type: string;
     tsType?: string;
@@ -84,8 +165,9 @@ declare enum NullableResult {
 }
 export declare const knownAllowedNames: Map<string, string>;
 export declare const knownDisAllowedNames: Map<string, boolean>;
-export declare const isCustomType: (type: Type) => type is CustomType;
-export declare const addCustomType: (type: CustomType) => void;
+export declare const knownInterfaces: Map<string, boolean>;
+export declare const isCustomType: (type: Type) => type is CustomTypeInput;
+export declare const addCustomType: (type: CustomTypeInput, gqlCapture: typeof GQLCapture) => Promise<void>;
 export declare class GQLCapture {
     private static enabled;
     static enable(enabled: boolean): void;
@@ -96,6 +178,8 @@ export declare class GQLCapture {
     private static customArgs;
     private static customInputObjects;
     private static customObjects;
+    private static customInterfaces;
+    private static customUnions;
     private static customTypes;
     static clear(): void;
     static getCustomFields(): Map<string, CustomField[]>;
@@ -104,36 +188,38 @@ export declare class GQLCapture {
     static getCustomArgs(): Map<string, CustomObject>;
     static getCustomInputObjects(): Map<string, CustomObject>;
     static getCustomObjects(): Map<string, CustomObject>;
+    static getCustomInterfaces(): Map<string, CustomObject>;
+    static getCustomUnions(): Map<string, CustomObject>;
     static getCustomTypes(): Map<string, CustomType>;
     private static getNullableArg;
     static getProcessedCustomFields(): ProcessCustomFieldMap;
     static getProcessedCustomMutations(): ProcessedCustomField[];
     static getProcessedCustomQueries(): ProcessedCustomField[];
     private static getProcessedCustomFieldsImpl;
-    private static getResultFromMetadata;
-    static gqlField(options?: gqlFieldOptions): any;
+    private static getField;
+    static gqlField(options: gqlFieldOptions): any;
     private static getCustomField;
-    private static argMap;
-    private static argImpl;
-    static gqlArg(name: string, options?: gqlFieldOptions): any;
-    static gqlContextType(): any;
+    static gqlContextType(): gqlFieldArg;
     static gqlArgType(options?: gqlObjectOptions): any;
     static gqlInputObjectType(options?: gqlObjectOptions): any;
-    static gqlObjectType(options?: gqlObjectOptions): any;
+    static gqlObjectType(options?: gqlObjectWithInterfaceOptions): any;
+    static gqlUnionType(options: gqlObjectWithUnionOptions): any;
+    static gqlInterfaceType(options?: gqlObjectOptions): any;
     private static customGQLObject;
-    static gqlQuery(options?: gqlTopLevelOptions): any;
-    static gqlMutation(options?: gqlTopLevelOptions): any;
+    static gqlQuery(options: gqlQueryOptions): any;
+    static gqlMutation(options: gqlMutationOptions): any;
     static gqlConnection(type: Type): any;
     static resolve(objects: string[]): void;
 }
 export declare const gqlField: typeof GQLCapture.gqlField;
-export declare const gqlArg: typeof GQLCapture.gqlArg;
 export declare const gqlArgType: typeof GQLCapture.gqlArgType;
 export declare const gqlInputObjectType: typeof GQLCapture.gqlInputObjectType;
 export declare const gqlObjectType: typeof GQLCapture.gqlObjectType;
+export declare const gqlInterfaceType: typeof GQLCapture.gqlInterfaceType;
+export declare const gqlUnionType: typeof GQLCapture.gqlUnionType;
 export declare const gqlQuery: typeof GQLCapture.gqlQuery;
 export declare const gqlMutation: typeof GQLCapture.gqlMutation;
 export declare const gqlContextType: typeof GQLCapture.gqlContextType;
 export declare const gqlConnection: typeof GQLCapture.gqlConnection;
-declare const gqlFileUpload: CustomType;
+declare const gqlFileUpload: CustomTypeInput;
 export { gqlFileUpload };