@snowtop/ent 0.1.0-alpha160-test4 → 0.1.0-alpha160-test6

package/src/core/config.ts

@@ -0,0 +1,219 @@
+import * as fs from "fs";
+import { load } from "js-yaml";
+import DB, { Database, DBDict } from "./db";
+import * as path from "path";
+import { setLogLevels } from "./logger";
+import { ___setLogQueryErrorWithError, setDefaultLimit } from "./ent";
+
+type logType = "query" | "warn" | "info" | "error" | "debug";
+
+// ent.config.ts eventually. for now ent.yml
+// or ent.yml?
+
+enum graphqlMutationName {
+  NOUN_VERB = "NounVerb",
+  VERB_NOUN = "VerbNoun",
+}
+
+enum graphQLFieldFormat {
+  LOWER_CAMEL = "lowerCamel",
+  SNAKE_CASE = "snake_case",
+}
+
+enum fieldPrivacyEvaluated {
+  AT_ENT_LOAD = "at_ent_load",
+  ON_DEMAND = "on_demand",
+}
+
+// runtime configurations
+export interface Config {
+  dbConnectionString?: string;
+  dbFile?: string; // config/database.yml is default
+  db?: Database | DBDict;
+  log?: logType | logType[]; // default is 'error'
+  // warn will be deprecared or weird things
+  // info is tbd. graphql/performance/timing/request stuff
+  // query includes cache hit. redis|memcache etc eventually
+
+  // logQueryWithError
+  logQueryWithError?: boolean;
+
+  // override the default limit for edges and connections.
+  // right now, it's 1000 but can be overriden to set a higher or lower limit
+  defaultConnectionLimit?: number;
+}
+
+// things that can be set in ent.yml
+export interface ConfigWithCodegen extends Config {
+  // config for codegen
+  codegen?: CodegenConfig;
+
+  // because of swc issues, we might not be able to
+  // parse custom graphql via decorators so we put this
+  // in a json file for now
+  // the path should be relative to the root
+  // this is hopefully a temporary solution...
+  customGraphQLJSONPath?: string;
+
+  // dynamically add things to be considered in addition to customGraphQLJSONPath
+  // see examples for how it's used
+  dynamicScriptCustomGraphQLJSONPath?: string;
+
+  // defaults to __global__schema.ts if not provided
+  // relative to src/schema for now
+  globalSchemaPath?: string;
+}
+
+interface CodegenConfig {
+  defaultEntPolicy?: PrivacyConfig;
+  defaultActionPolicy?: PrivacyConfig;
+  prettier?: PrettierConfig;
+  // use relativeImports in generated files instead of "src/ent/user" etc
+  // needed for legacy scenarios or situations where the custom compiler has issues
+  relativeImports?: boolean;
+  // the default graphql root is src/graphql/index.ts
+  // if integrating into an existing project (with an existing root) or just
+  // want to do something different, set this to true
+  disableGraphQLRoot?: boolean;
+  // add header to each generated file
+  // if provided, we'd generate a header as follows:
+  // /**
+  //  * Copyright blah
+  //  * Generated by github.com/lolopinto/... DO NOT EDIT.
+  //
+  //  */
+  // If not provided, we'd do just:
+  // // Generated by github.com/lolopinto/ent, DO NOT EDIT."
+  // For files that are generated only once e.g. (src/ent/user.ts), if they exist on disk before this is provided,
+  // they are not changed
+  generatedHeader?: string;
+
+  // disable base64encoding of id fields
+  // when set to true, id fields aren't resolved with nodeIDEncoder and the actual uuid or integer is sent to the client
+  disableBase64Encoding?: boolean;
+
+  // generateRootResolvers for each type exposed to GraphQL instead of node(). Should be used in combination with
+  // disableBase64Encoding
+  generateRootResolvers?: boolean;
+
+  // default names for graphql actions|mutations is nounVerb e.g. userCreate
+  // if you wanna change it to verbNoun e.g. createUser, set this field to VERB_NOUN
+  defaultGraphQLMutationName?: graphqlMutationName;
+
+  // default format for fields is lowerCamelCase e.g. firstName
+  // if you wanna change it to snake_case e.g. first_name, set this field to snake_case
+  defaultGraphQLFieldFormat?: graphQLFieldFormat;
+
+  // if we should generate schema.sql file and path to generate it
+  schemaSQLFilePath?: boolean;
+
+  // TODO: would be ideal not to need this. so eventually make this work without
+  // if there's a schemaSQLFilePath, we compare against an empty database to see what
+  // has changed. we need this because if no database is provided, we'd then try and compare
+  // against database with same name as user
+  databaseToCompareTo?: string;
+
+  // copied from schema.ts
+  // when field privacy is evaluated.
+  // field can have privacy policy
+  // there's 2 modes of how this is treated that can be configured in ent.yml because it affects codegen
+  // 1: evaluate at the time of ent load, we apply the privacy of each object and then apply the privacy of every
+  // field which has field privacy and set the property to null if the field is not visible to the viewer
+  // The underlying column is no longer in the `data` field of the object
+  // 2: generate accessors for the field and all callsites which reference that field will use that.
+  // the privacy will be evaluated on demand when needed
+
+  // default is on_demand
+  fieldPrivacyEvaluated?: fieldPrivacyEvaluated;
+
+  templatizedViewer?: importedObject;
+
+  // if you want a new base class for AssocEdge e.g. to get extra data stored in custom assoc table
+  customAssocEdgePath?: importedObject;
+
+  // path to add to src/ent/internal.ts so that it's included everywhere
+  // where things like global augmentation can be done
+  // https://www.typescriptlang.org/docs/handbook/declaration-merging.html#global-augmentation
+  globalImportPath?: string;
+
+  userOveriddenFiles?: string[];
+}
+
+interface PrettierConfig {
+  // indicates you have your own custom prettier configuration and should use that instead of the ent default
+  // https://prettier.io/docs/en/configuration.html
+  custom?: boolean;
+  // default glob is 'src/**/*.ts', can override this
+  glob?: string;
+}
+
+interface PrivacyConfig {
+  path: string; // e.g. "@snowtop/ent"
+  policyName: string; // e.g. "AllowIfViewerHasIdentityPrivacyPolicy";
+  class?: boolean;
+}
+
+interface importedObject {
+  path: string;
+  name: string;
+  alias?: string;
+}
+
+function setConfig(cfg: Config) {
+  if (cfg.log) {
+    setLogLevels(cfg.log);
+  }
+
+  if (cfg.dbConnectionString || cfg.dbFile || cfg.db) {
+    DB.initDB({
+      connectionString: cfg.dbConnectionString,
+      dbFile: cfg.dbFile,
+      db: cfg.db,
+    });
+  }
+
+  ___setLogQueryErrorWithError(cfg.logQueryWithError);
+
+  if (cfg.defaultConnectionLimit) {
+    setDefaultLimit(cfg.defaultConnectionLimit);
+  }
+}
+
+function isBuffer(b: Buffer | Config): b is Buffer {
+  return (b as Buffer).write !== undefined;
+}
+
+export function loadConfig(file?: string | Buffer | Config) {
+  let data: string;
+  if (typeof file === "object") {
+    if (!isBuffer(file)) {
+      return setConfig(file);
+    }
+    data = file.toString();
+  } else {
+    file = file || "ent.yml";
+    if (!path.isAbsolute(file)) {
+      file = path.join(process.cwd(), file);
+    }
+    if (!fs.existsSync(file)) {
+      return DB.initDB();
+    }
+    try {
+      data = fs.readFileSync(file, { encoding: "utf8" });
+    } catch (e) {
+      console.error(`error opening file: ${file}`);
+      return DB.initDB();
+    }
+  }
+
+  try {
+    let yaml = load(data);
+    if (typeof yaml !== "object") {
+      throw new Error(`invalid yaml passed`);
+    }
+    setConfig(yaml as Config);
+  } catch (e) {
+    console.error(`error parsing yaml file`, e);
+    throw e;
+  }
+}

package/src/core/const.ts

@@ -0,0 +1,5 @@
+export const PACKAGE = "@snowtop/ent";
+
+export const GRAPHQL_PATH = "@snowtop/ent/graphql";
+
+export const SCHEMA_PATH = "@snowtop/ent/schema";

package/src/core/context.ts

@@ -0,0 +1,135 @@
+import { Viewer, Data, Loader, LoaderWithLoadMany } from "./base";
+import { IncomingMessage, ServerResponse } from "http";
+
+import * as clause from "./clause";
+import { log } from "./logger";
+import { Context } from "./base";
+import { OrderBy, getOrderByPhrase } from "./query_impl";
+
+// RequestBasedContext e.g. from an HTTP request with a server/response conponent
+export interface RequestContext<TViewer extends Viewer = Viewer>
+  extends Context<TViewer> {
+  authViewer(viewer: TViewer): Promise<void>; //logs user in and changes viewer to this
+  logout(): Promise<void>;
+  request: IncomingMessage;
+  response: ServerResponse;
+}
+
+export class ContextCache {
+  loaders: Map<string, Loader<any, any>> = new Map();
+  // we should eventually combine the two but better for typing to be separate for now
+  loaderWithLoadMany: Map<string, LoaderWithLoadMany<any, any>> = new Map();
+
+  getLoader<K, V>(name: string, create: () => Loader<K, V>): Loader<K, V> {
+    let l = this.loaders.get(name);
+    if (l) {
+      return l;
+    }
+    log("debug", `new context-aware loader created for ${name}`);
+    l = create();
+    this.loaders.set(name, l);
+    return l;
+  }
+
+  getLoaderWithLoadMany<K, V>(
+    name: string,
+    create: () => LoaderWithLoadMany<K, V>,
+  ): LoaderWithLoadMany<K, V> {
+    let l = this.loaderWithLoadMany.get(name);
+    if (l) {
+      return l;
+    }
+    log("debug", `new context-aware loader created for ${name}`);
+    l = create();
+    this.loaderWithLoadMany.set(name, l);
+    return l;
+  }
+
+  // we have a per-table map to make it easier to purge and have less things to compare with
+  private itemMap: Map<string, Map<string, Data>> = new Map();
+  private listMap: Map<string, Map<string, Data[]>> = new Map();
+
+  // tableName is ignored bcos already indexed on that
+  // maybe we just want to store sql queries???
+
+  private getkey(options: queryOptions): string {
+    let parts: string[] = [
+      options.fields.join(","),
+      options.clause.instanceKey(),
+    ];
+    if (options.orderby) {
+      parts.push(getOrderByPhrase(options.orderby));
+    }
+    return parts.join(",");
+  }
+
+  getCachedRows(options: queryOptions): Data[] | null {
+    let m = this.listMap.get(options.tableName);
+    if (!m) {
+      return null;
+    }
+    const key = this.getkey(options);
+    let rows = m.get(key);
+    if (rows) {
+      log("cache", {
+        "cache-hit": key,
+        "tableName": options.tableName,
+      });
+    }
+    return rows || null;
+  }
+
+  getCachedRow(options: queryOptions): Data | null {
+    let m = this.itemMap.get(options.tableName);
+    if (!m) {
+      return null;
+    }
+    const key = this.getkey(options);
+    let row = m.get(key);
+    if (row) {
+      log("cache", {
+        "cache-hit": key,
+        "tableName": options.tableName,
+      });
+    }
+    return row || null;
+  }
+
+  primeCache(options: queryOptions, rows: Data[]): void;
+  primeCache(options: queryOptions, rows: Data): void;
+  primeCache(options: queryOptions, rows: Data[] | Data): void {
+    if (Array.isArray(rows)) {
+      let m = this.listMap.get(options.tableName) || new Map();
+      m.set(this.getkey(options), rows);
+      this.listMap.set(options.tableName, m);
+    } else {
+      let m = this.itemMap.get(options.tableName) || new Map();
+      m.set(this.getkey(options), rows);
+      this.itemMap.set(options.tableName, m);
+    }
+  }
+
+  clearCache(): void {
+    for (const [_key, loader] of this.loaders) {
+      // may not need this since we're clearing the loaders themselves...
+      // but may have some benefits by explicitily doing so?
+      loader.clearAll();
+    }
+    for (const [_key, loader] of this.loaderWithLoadMany) {
+      // may not need this since we're clearing the loaders themselves...
+      // but may have some benefits by explicitily doing so?
+      loader.clearAll();
+    }
+    this.loaders.clear();
+    this.loaderWithLoadMany.clear();
+    this.itemMap.clear();
+    this.listMap.clear();
+  }
+}
+
+interface queryOptions {
+  fields: string[];
+  tableName: string;
+  clause: clause.Clause;
+  orderby?: OrderBy;
+}

package/src/core/convert.ts

@@ -0,0 +1,106 @@
+import { DateTime } from "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
+// see Sqlite.execSync
+export function convertDate(val: any): Date {
+  if (typeof val === "string") {
+    // try luxon first if in ISO format. If that doesn't work, fall back to Date.prse
+    const dt = DateTime.fromISO(val);
+    if (dt.isValid) {
+      return dt.toJSDate();
+    }
+    return new Date(Date.parse(val));
+  }
+  // assume date
+  return val;
+}
+
+export function convertNullableDate(val: any): Date | null {
+  if (val === null) {
+    return null;
+  }
+  return convertDate(val);
+}
+
+export function convertBool(val: any): boolean {
+  if (typeof val === "number") {
+    // assume 1 or 0
+    return val != 0;
+  }
+  // assume boolean
+  return val;
+}
+
+export function convertNullableBool(val: any): boolean | null {
+  if (val === null) {
+    return null;
+  }
+  return convertBool(val);
+}
+
+export function convertList<T>(val: any, conv?: (val: any) => T): T[] {
+  if (Array.isArray(val)) {
+    return val;
+  }
+
+  let res = JSON.parse(val);
+  if (!conv) {
+    return res;
+  }
+  if (!Array.isArray(res)) {
+    throw new Error(`got a non-array from the db: ${val}`);
+  }
+  for (let i = 0; i < res.length; i++) {
+    res[i] = conv(res[i]);
+  }
+  return res;
+}
+
+export function convertNullableList<T>(
+  val: any,
+  conv?: (val: any) => T,
+): T[] | null {
+  // undefined can happen with unsafe ents
+  if (val === null || val === undefined) {
+    return null;
+  }
+  return convertList(val, conv);
+}
+
+export function convertDateList(val: any): Date[] {
+  return convertList(val, convertDate);
+}
+
+export function convertNullableDateList(val: any): Date[] | null {
+  return convertNullableList(val, convertDate);
+}
+
+export function convertBoolList(val: any): boolean[] {
+  return convertList(val, convertBool);
+}
+
+export function convertNullableBoolList(val: any): boolean[] | null {
+  return convertNullableList(val, convertBool);
+}
+
+export function convertJSON(val: any): any {
+  if (typeof val === "string") {
+    return JSON.parse(val);
+  }
+  return val;
+}
+
+export function convertNullableJSON(val: any): any | null {
+  if (val === null) {
+    return val;
+  }
+  return convertJSON(val);
+}
+
+export function convertJSONList(val: any): any[] {
+  return convertList(val, convertJSON);
+}
+
+export function convertNullableJSONList(val: any): any[] | null {
+  return convertNullableList(val, convertJSON);
+}

package/src/core/date.ts

@@ -0,0 +1,23 @@
+import { DateTime } from "luxon";
+
+export function parseDate(val: any, throwErr: (s: string) => Error): DateTime {
+  let dt: DateTime;
+  if (typeof val === "number") {
+    dt = DateTime.fromMillis(val);
+  } else if (typeof val === "string") {
+    dt = DateTime.fromISO(val);
+    if (!dt.isValid) {
+      dt = DateTime.fromMillis(Date.parse(val));
+    }
+  } else if (val instanceof Date) {
+    dt = DateTime.fromJSDate(val);
+  } else if (val instanceof DateTime) {
+    dt = val;
+  } else {
+    throw throwErr(`invalid input for type Time ${val}`);
+  }
+  if (!dt.isValid) {
+    throw throwErr(`invalid input for type Time ${val}`);
+  }
+  return dt;
+}