@snowtop/ent 0.1.0-alpha114 → 0.1.0-alpha116

package/action/orchestrator.js

@@ -290,6 +290,18 @@ class Orchestrator {
             if (!val) {
                 continue;
             }
+            if (field.valid) {
+                let valid = field.valid(val);
+                if (util_1.types.isPromise(valid)) {
+                    valid = await valid;
+                }
+                // if not valid, don't format and don't pass to ent?
+                // or just early throw here
+                if (!valid) {
+                    continue;
+                    // throw new Error(`invalid field ${fieldName} with value ${val}`);
+                }
+            }
             // nested so it's not JSON stringified or anything like that
             val = field.format(formatted[dbKey], true);
             if (util_1.types.isPromise(val)) {

package/core/base.d.ts

@@ -1,8 +1,8 @@
 import * as clause from "./clause";
-export interface Loader<T, V> {
+export interface Loader<K, V> {
     context?: Context;
-    load(key: T): Promise<V>;
-    loadMany?(keys: T[]): Promise<(V | null)[]>;
+    load(key: K): Promise<V>;
+    loadMany?(keys: K[]): Promise<(V | null)[]>;
     clearAll(): any;
 }
 export interface LoaderWithLoadMany<T, V> extends Loader<T, V> {
@@ -19,13 +19,13 @@ export interface ConfigurableLoaderFactory<T, V> extends LoaderFactory<T, V> {
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<T, V>;
 }
 export type EdgeQueryableDataOptions = Partial<Pick<QueryableDataOptions, "limit" | "orderby" | "clause">>;
-export interface PrimableLoader<T, V> extends Loader<T, V> {
-    prime(d: Data): void;
-    primeAll?(d: Data): void;
+export interface PrimableLoader<K, V> extends Loader<K, V> {
+    prime(d: V): void;
+    primeAll?(d: V): void;
 }
 interface cache {
-    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
-    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
+    getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
+    getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     getCachedRows(options: queryOptions): Data[] | null;
     getCachedRow(options: queryOptions): Data | null;
     primeCache(options: queryOptions, rows: Data[]): void;
@@ -113,11 +113,11 @@ export interface LoadCustomEntOptions<TEnt extends Ent, TViewer extends Viewer =
     ent: EntConstructor<TEnt, TViewer>;
     fieldPrivacy?: Map<string, PrivacyPolicy>;
 }
-export interface LoaderInfo {
+export interface LoaderInfo<T = Data> {
     tableName: string;
     fields: string[];
     nodeType: string;
-    loaderFactory: LoaderFactory<any, Data | null>;
+    loaderFactory: LoaderFactory<ID, T | null>;
 }
 export interface EditEntOptions<T extends Ent> extends LoadableEntOptions<T>, EditRowOptions {
 }

package/core/context.d.ts

@@ -12,8 +12,8 @@ export interface RequestContext<TViewer extends Viewer = Viewer> extends Context
 export declare class ContextCache {
     loaders: Map<string, Loader<any, any>>;
     loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>>;
-    getLoader<T, V>(name: string, create: () => Loader<T, V>): Loader<T, V>;
-    getLoaderWithLoadMany<T, V>(name: string, create: () => LoaderWithLoadMany<T, V>): LoaderWithLoadMany<T, V>;
+    getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V>;
+    getLoaderWithLoadMany<K, V>(name: string, create: () => LoaderWithLoadMany<K, V>): LoaderWithLoadMany<K, V>;
     private itemMap;
     private listMap;
     private getkey;

package/core/loaders/index_loader.d.ts

@@ -7,7 +7,7 @@ export declare class IndexLoaderFactory implements LoaderFactory<ID, Data[]> {
     constructor(options: SelectBaseDataOptions, col: string, opts?: {
         extraClause?: clause.Clause;
         sortColumn?: string;
-        toPrime?: ObjectLoaderFactory<ID>[];
+        toPrime?: ObjectLoaderFactory<Data>[];
     });
     createLoader(context?: Context): any;
     createConfigurableLoader(options: EdgeQueryableDataOptions, context?: Context): Loader<ID, Data[]>;

package/core/loaders/loader.d.ts

@@ -1,6 +1,6 @@
 import { Loader, LoaderFactory, Context, DataOptions } from "../base";
-export declare function getLoader<T, V>(factory: LoaderFactory<T, V>, create: () => Loader<T, V>, context?: Context): Loader<T, V>;
-export declare function getCustomLoader<T, V>(key: string, create: () => Loader<T, V>, context?: Context): Loader<T, V>;
+export declare function getLoader<K, V>(factory: LoaderFactory<K, V>, create: () => Loader<K, V>, context?: Context): Loader<K, V>;
+export declare function getCustomLoader<K, V>(key: string, create: () => Loader<K, V>, context?: Context): Loader<K, V>;
 export declare class cacheMap {
     private options;
     private m;

package/core/loaders/object_loader.d.ts

@@ -1,29 +1,29 @@
 import { ID, Data, SelectDataOptions, Context, Loader, LoaderFactory } from "../base";
-export declare class ObjectLoader<T> implements Loader<T, Data | null> {
+export declare class ObjectLoader<V = Data> implements Loader<ID, V | null> {
     private options;
     context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined;
     private toPrime?;
     private loader;
     private primedLoaders;
     private memoizedInitPrime;
-    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<T>[] | undefined);
+    constructor(options: SelectDataOptions, context?: Context<import("../base").Viewer<import("../base").Ent<any> | null, ID | null>> | undefined, toPrime?: ObjectLoaderFactory<V>[] | undefined);
     getOptions(): SelectDataOptions;
     private initPrime;
-    load(key: T): Promise<Data | null>;
+    load(key: ID): Promise<V | null>;
     clearAll(): void;
-    loadMany(keys: T[]): Promise<Array<Data | null>>;
-    prime(data: Data): void;
-    primeAll(data: Data): void;
+    loadMany(keys: ID[]): Promise<Array<V | null>>;
+    prime(data: V): void;
+    primeAll(data: V): void;
 }
 interface ObjectLoaderOptions extends SelectDataOptions {
     instanceKey?: string;
 }
-export declare class ObjectLoaderFactory<T> implements LoaderFactory<T, Data | null> {
+export declare class ObjectLoaderFactory<V = Data> implements LoaderFactory<ID, V | null> {
     options: ObjectLoaderOptions;
     name: string;
     private toPrime;
     constructor(options: ObjectLoaderOptions);
-    createLoader(context?: Context): ObjectLoader<T>;
-    addToPrime(factory: ObjectLoaderFactory<T>): this;
+    createLoader(context?: Context): ObjectLoader<V>;
+    addToPrime(factory: ObjectLoaderFactory<V>): this;
 }
 export {};

package/core/loaders/object_loader.js

@@ -60,7 +60,7 @@ async function loadRowsForLoader(options, ids, context) {
         // store the index....
         m.set(ids[i], i);
     }
-    const rows = await (0, ent_1.loadRows)(rowOptions);
+    const rows = (await (0, ent_1.loadRows)(rowOptions));
     for (const row of rows) {
         const id = row[col];
         if (id === undefined) {
@@ -162,7 +162,8 @@ class ObjectLoader {
     }
     async loadMany(keys) {
         if (this.loader) {
-            return await this.loader.loadMany(keys);
+            // @ts-expect-error TODO?
+            return this.loader.loadMany(keys);
         }
         return loadRowsForLoader(this.options, keys, this.context);
     }

package/core/loaders/query_loader.d.ts

@@ -19,7 +19,7 @@ interface QueryOptions {
     groupCol?: string;
     clause?: clause.Clause;
     sortColumn?: string;
-    toPrime?: ObjectLoaderFactory<ID>[];
+    toPrime?: ObjectLoaderFactory<Data>[];
 }
 export declare class QueryLoaderFactory<K extends any> implements LoaderFactory<K, Data[]> {
     private options;

package/package.json

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

package/testutils/fake_data/fake_contact.d.ts

@@ -34,4 +34,4 @@ export interface ContactCreateInput {
 }
 export declare function getContactBuilder(viewer: Viewer, input: ContactCreateInput): SimpleBuilder<FakeContact, null>;
 export declare function createContact(viewer: Viewer, input: ContactCreateInput): Promise<void>;
-export declare const contactLoader: ObjectLoaderFactory<unknown>;
+export declare const contactLoader: ObjectLoaderFactory<Data>;

package/testutils/fake_data/fake_tag.d.ts

@@ -33,4 +33,4 @@ export type TagEditInput = Partial<TagCreateInput>;
 export declare function getTagBuilder(viewer: Viewer, input: TagCreateInput): import("../builder").SimpleBuilder<FakeTag, null>;
 export declare function getTagAction(viewer: Viewer, input: TagCreateInput): SimpleAction<FakeTag, null>;
 export declare function createTag(viewer: Viewer, input: TagCreateInput): Promise<FakeTag>;
-export declare const tagLoader: ObjectLoaderFactory<unknown>;
+export declare const tagLoader: ObjectLoaderFactory<Data>;

package/testutils/fake_data/fake_user.d.ts

@@ -46,7 +46,7 @@ export type UserEditInput = Partial<UserCreateInput>;
 export declare function getUserBuilder(viewer: Viewer, input: UserCreateInput): import("../builder").SimpleBuilder<FakeUser, null>;
 export declare function getUserAction(viewer: Viewer, input: UserCreateInput): SimpleAction<FakeUser, null>;
 export declare function createUser(viewer: Viewer, input: UserCreateInput): Promise<FakeUser>;
-export declare const userLoader: ObjectLoaderFactory<unknown>;
-export declare const userEmailLoader: ObjectLoaderFactory<unknown>;
-export declare const userPhoneNumberLoader: ObjectLoaderFactory<unknown>;
+export declare const userLoader: ObjectLoaderFactory<Data>;
+export declare const userEmailLoader: ObjectLoaderFactory<Data>;
+export declare const userPhoneNumberLoader: ObjectLoaderFactory<Data>;
 export {};