@snowtop/ent 0.1.0-alpha6 → 0.1.0-alpha63

package/core/db.d.ts

@@ -1,11 +1,10 @@
-import { Pool, ClientConfig, PoolClient } from "pg";
-export interface Database {
+import { Pool, PoolClient, PoolConfig } from "pg";
+export interface Database extends PoolConfig {
     database?: string;
     user?: string;
     password?: string;
     host?: string;
     port?: number;
-    ssl?: boolean;
     sslmode?: string;
 }
 export declare type env = "production" | "test" | "development";
@@ -16,7 +15,7 @@ export declare enum Dialect {
 }
 interface DatabaseInfo {
     dialect: Dialect;
-    config: ClientConfig;
+    config: PoolConfig;
     filePath?: string;
 }
 export default class DB {

package/core/db.js

@@ -109,6 +109,8 @@ function getClientConfig(args) {
                     host: cfg.host,
                     port: cfg.port,
                     ssl: cfg.sslmode == "enable",
+                    // max, min, etc
+                    ...cfg,
                 },
             };
         }

package/core/ent.d.ts

@@ -1,19 +1,20 @@
 import { Queryer, SyncQueryer } from "./db";
-import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions, EntConstructor } from "./base";
+import { Viewer, Ent, ID, LoadRowsOptions, LoadRowOptions, Data, DataOptions, QueryableDataOptions, EditRowOptions, LoadEntOptions, LoadCustomEntOptions, EdgeQueryableDataOptions, Context, SelectBaseDataOptions, CreateRowOptions, QueryDataOptions } from "./base";
 import { Executor } from "../action/action";
 import * as clause from "./clause";
 import { Builder } from "../action";
 import DataLoader from "dataloader";
-export declare function loadEnt<T extends Ent>(viewer: Viewer, id: ID, options: LoadEntOptions<T>): Promise<T | null>;
-export declare function loadEntViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T | null>;
-export declare function loadEntX<T extends Ent>(viewer: Viewer, id: ID, options: LoadEntOptions<T>): Promise<T>;
-export declare function loadEntXViaKey<T extends Ent>(viewer: Viewer, key: any, options: LoadEntOptions<T>): Promise<T>;
-export declare function loadEntFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T | null>;
-export declare function loadEntXFromClause<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, clause: clause.Clause): Promise<T>;
-export declare function loadEnts<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<Map<ID, T>>;
-export declare function loadEntsList<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, ...ids: ID[]): Promise<T[]>;
-export declare function loadEntsFromClause<T extends Ent>(viewer: Viewer, clause: clause.Clause, options: LoadEntOptions<T>): Promise<Map<ID, T>>;
-export declare function loadCustomEnts<T extends Ent>(viewer: Viewer, options: LoadCustomEntOptions<T>, query: CustomQuery): Promise<T[]>;
+import { GlobalSchema } from "../schema/";
+export declare function loadEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
+export declare function loadEntViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
+export declare function loadEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id: ID, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
+export declare function loadEntXViaKey<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, key: any, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt>;
+export declare function loadEntFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, clause: clause.Clause): Promise<TEnt | null>;
+export declare function loadEntXFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, clause: clause.Clause): Promise<TEnt>;
+export declare function loadEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, ...ids: ID[]): Promise<Map<ID, TEnt>>;
+export declare function loadEntsList<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, ...ids: ID[]): Promise<TEnt[]>;
+export declare function loadEntsFromClause<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, clause: clause.Clause, options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
+export declare function loadCustomEnts<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadCustomEntOptions<TEnt, TViewer>, query: CustomQuery): Promise<TEnt[]>;
 interface rawQueryOptions {
     query: string;
     values?: any[];
@@ -21,10 +22,8 @@ interface rawQueryOptions {
 }
 export declare type CustomQuery = string | rawQueryOptions | clause.Clause | QueryDataOptions;
 export declare function loadCustomData(options: SelectBaseDataOptions, query: CustomQuery, context: Context | undefined): Promise<Data[]>;
-export declare function loadDerivedEnt<T extends Ent>(viewer: Viewer, data: Data, loader: new (viewer: Viewer, data: Data) => T): Promise<T | null>;
-export declare function loadDerivedEntX<T extends Ent>(viewer: Viewer, data: Data, loader: new (viewer: Viewer, data: Data) => T): Promise<T>;
-export declare function applyPrivacyPolicyForEnt<T extends Ent>(viewer: Viewer, ent: T | null): Promise<T | null>;
-export declare function applyPrivacyPolicyForEntX<T extends Ent>(viewer: Viewer, ent: T): Promise<T>;
+export declare function loadDerivedEnt<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt | null>;
+export declare function loadDerivedEntX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, data: Data, loader: new (viewer: TViewer, data: Data) => TEnt): Promise<TEnt>;
 export declare function loadRowX(options: LoadRowOptions): Promise<Data>;
 export declare function loadRow(options: LoadRowOptions): Promise<Data | null>;
 export declare function performRawQuery(query: string, values: any[], logValues?: any[]): Promise<Data[]>;
@@ -52,8 +51,9 @@ export interface DataOperation<T extends Ent = Ent> {
 }
 export interface EditNodeOptions<T extends Ent> extends EditRowOptions {
     fieldsToResolve: string[];
-    ent: EntConstructor<T>;
+    loadEntOptions: LoadEntOptions<T>;
     placeholderID?: ID;
+    key: string;
 }
 export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     options: EditNodeOptions<T>;
@@ -69,7 +69,11 @@ export declare class EditNodeOperation<T extends Ent> implements DataOperation {
     returnedRow(): Data | null;
     createdEnt(viewer: Viewer): T | null;
 }
+export declare function setGlobalSchema(val: GlobalSchema): void;
+export declare function clearGlobalSchema(): void;
+export declare function __hasGlobalSchema(): boolean;
 export declare class EdgeOperation implements DataOperation {
+    private builder;
     edgeInput: AssocEdgeInput;
     private options;
     private edgeData;
@@ -98,9 +102,9 @@ export declare class EdgeOperation implements DataOperation {
 export declare function buildInsertQuery(options: CreateRowOptions, suffix?: string): [string, string[], string[]];
 export declare function createRow(queryer: Queryer, options: CreateRowOptions, suffix: string): Promise<Data | null>;
 export declare function createRowSync(queryer: SyncQueryer, options: CreateRowOptions, suffix: string): Data | null;
-export declare function buildUpdateQuery(options: EditRowOptions, id: ID, suffix?: string): [string, any[], any[]];
-export declare function editRow(queryer: Queryer, options: EditRowOptions, id: ID, suffix?: string): Promise<Data | null>;
-export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, id: ID, suffix?: string): Data | null;
+export declare function buildUpdateQuery(options: EditRowOptions, suffix?: string): [string, any[], any[]];
+export declare function editRow(queryer: Queryer, options: EditRowOptions, suffix?: string): Promise<Data | null>;
+export declare function editRowSync(queryer: SyncQueryer, options: EditRowOptions, suffix?: string): Data | null;
 export declare function deleteRows(queryer: Queryer, options: DataOptions, cls: clause.Clause): Promise<void>;
 export declare function deleteRowsSync(queryer: SyncQueryer, options: DataOptions, cls: clause.Clause): void;
 export declare class DeleteNodeOperation implements DataOperation {
@@ -118,7 +122,9 @@ export declare class AssocEdge {
     id2Type: string;
     time: Date;
     data?: string | null;
+    private rawData;
     constructor(data: Data);
+    __getRawData(): Data;
     getCursor(): string;
 }
 interface cursorOptions {
@@ -147,7 +153,7 @@ export declare class AssocEdgeData {
     edgeTable: string;
     constructor(data: Data);
 }
-export declare const assocEdgeLoader: DataLoader<any, any, any>;
+export declare const assocEdgeLoader: DataLoader<ID, Data | null, ID>;
 export declare function loadEdgeData(edgeType: string): Promise<AssocEdgeData | null>;
 export declare function loadEdgeDatas(...edgeTypes: string[]): Promise<Map<string, AssocEdgeData>>;
 export interface AssocEdgeConstructor<T extends AssocEdge> {
@@ -158,6 +164,7 @@ interface loadEdgesOptions {
     edgeType: string;
     context?: Context;
     queryOptions?: EdgeQueryableDataOptions;
+    disableTransformations?: boolean;
 }
 interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
     ctr: AssocEdgeConstructor<T>;
@@ -165,17 +172,21 @@ interface loadCustomEdgesOptions<T extends AssocEdge> extends loadEdgesOptions {
 export declare const DefaultLimit = 1000;
 export declare function defaultEdgeQueryOptions(id1: ID, edgeType: string): EdgeQueryableDataOptions;
 export declare function loadEdges(options: loadEdgesOptions): Promise<AssocEdge[]>;
+export declare function getEdgeClauseAndFields(cls: clause.Clause, options: loadEdgesOptions): {
+    cls: clause.Clause;
+    fields: string[];
+};
 export declare function loadCustomEdges<T extends AssocEdge>(options: loadCustomEdgesOptions<T>): Promise<T[]>;
 export declare function loadUniqueEdge(options: loadEdgesOptions): Promise<AssocEdge | null>;
-export declare function loadUniqueNode<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T | null>;
+export declare function loadUniqueNode<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, id1: ID, edgeType: string, options: LoadEntOptions<TEnt, TViewer>): Promise<TEnt | null>;
 export declare function loadRawEdgeCountX(options: loadEdgesOptions): Promise<number>;
 interface loadEdgeForIDOptions<T extends AssocEdge> extends loadCustomEdgesOptions<T> {
     id2: ID;
 }
 export declare function loadEdgeForID2<T extends AssocEdge>(options: loadEdgeForIDOptions<T>): Promise<T | undefined>;
 export declare function loadNodesByEdge<T extends Ent>(viewer: Viewer, id1: ID, edgeType: string, options: LoadEntOptions<T>): Promise<T[]>;
-export declare function applyPrivacyPolicyForRow<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data | null): Promise<T | null>;
-export declare function applyPrivacyPolicyForRowX<T extends Ent>(viewer: Viewer, options: LoadEntOptions<T>, row: Data): Promise<T>;
-export declare function applyPrivacyPolicyForRows<T extends Ent>(viewer: Viewer, rows: Data[], options: LoadEntOptions<T>): Promise<Map<ID, T>>;
+export declare function applyPrivacyPolicyForRow<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data | null): Promise<TEnt | null>;
+export declare function applyPrivacyPolicyForRowX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, options: LoadEntOptions<TEnt, TViewer>, row: Data): Promise<TEnt>;
+export declare function applyPrivacyPolicyForRows<TEnt extends Ent<TViewer>, TViewer extends Viewer>(viewer: TViewer, rows: Data[], options: LoadEntOptions<TEnt, TViewer>): Promise<Map<ID, TEnt>>;
 export declare function getEdgeTypeInGroup<T extends string>(viewer: Viewer, id1: ID, id2: ID, m: Map<T, string>): Promise<[T, AssocEdge] | undefined>;
 export {};