@snowtop/ent 0.1.0-alpha160-test7 → 0.1.0-alpha160

package/src/schema/struct_field.ts

@@ -1,234 +0,0 @@
-import { camelCase } from "camel-case";
-import { BaseField, ListField } from "./field";
-import {
-  FieldOptions,
-  Field,
-  Type,
-  DBType,
-  FieldMap,
-  getStorageKey,
-} from "./schema";
-import {
-  __getGlobalSchemaField,
-  __getGlobalSchemaFields,
-} from "../core/global_schema";
-import { log } from "../core/logger";
-
-interface structFieldOptions extends FieldOptions {
-  // required.
-  // how does that jive with https://github.com/lolopinto/ent/issues/609 though??
-  tsType: string;
-  fields: FieldMap;
-  // if not provided, defaults to tsType
-  graphQLType?: string;
-  jsonNotJSONB?: boolean;
-}
-
-interface GlobalStructOptions extends FieldOptions {
-  globalType: string;
-}
-
-export type StructOptions = structFieldOptions | GlobalStructOptions;
-
-export class StructField extends BaseField implements Field {
-  type: Type = {
-    dbType: DBType.JSONB,
-  };
-
-  constructor(private options: StructOptions, private jsonAsList?: boolean) {
-    super();
-    this.type.subFields = options.fields;
-    this.type.type = options.tsType;
-    this.type.graphQLType = options.graphQLType || options.tsType;
-    this.type.globalType = this.options.globalType;
-    if (options.jsonNotJSONB) {
-      this.type.dbType = DBType.JSON;
-    }
-    if (jsonAsList) {
-      this.type.listElemType = {
-        dbType: DBType.JSONB,
-      };
-    }
-  }
-
-  formatImpl(obj: any, nested?: boolean) {
-    if (!(obj instanceof Object)) {
-      throw new Error("valid was not called");
-    }
-    let ret: Object = {};
-    for (const k in this.options.fields) {
-      const field = this.options.fields[k];
-
-      // check two values
-      // store in dbKey format
-
-      // TODO more #510
-      let dbKey = getStorageKey(field, k);
-      let camelKey = camelCase(k);
-      let val = obj[camelKey];
-
-      if (val === undefined && obj[dbKey] !== undefined) {
-        val = obj[dbKey];
-      }
-
-      if (val === undefined) {
-        continue;
-      }
-      if (field.format) {
-        // indicate nested so this isn't JSON stringified
-        ret[dbKey] = field.format(val, true);
-      } else {
-        ret[dbKey] = val;
-      }
-    }
-    // don't json.stringify if nested or list
-    if (nested) {
-      return ret;
-    }
-    return JSON.stringify(ret);
-  }
-
-  format(obj: any, nested?: boolean) {
-    if (this.type.globalType) {
-      const f = __getGlobalSchemaField(this.type.globalType);
-      if (f && f.format) {
-        if (
-          JSON.stringify(this.type.listElemType) !==
-          JSON.stringify(f?.type.listElemType)
-        ) {
-          if (this.jsonAsList) {
-            // handle as nested
-            // @ts-ignore
-            const formatted = obj.map((v: any) => f.format(v, true));
-            if (nested) {
-              return formatted;
-            } else {
-              return JSON.stringify(formatted);
-            }
-          } else {
-            const formatted = f.format([obj], true);
-            if (nested) {
-              return formatted[0];
-            } else {
-              return JSON.stringify(formatted[0]);
-            }
-          }
-        }
-
-        // TODO handle format code
-        return f.format(obj);
-      }
-    }
-    if (Array.isArray(obj) && this.jsonAsList) {
-      const ret = obj.map((v) => this.formatImpl(v, true));
-      if (nested) {
-        return ret;
-      }
-      return JSON.stringify(ret);
-    }
-    return this.formatImpl(obj, nested);
-  }
-
-  private async validImpl(obj: any) {
-    if (!(obj instanceof Object)) {
-      return false;
-    }
-
-    let promises: (boolean | Promise<boolean>)[] = [];
-    // TODO probably need to support optional fields...
-    let valid = true;
-    for (const k in this.options.fields) {
-      const field = this.options.fields[k];
-      // TODO more #510
-      let dbKey = getStorageKey(field, k);
-      let camelKey = camelCase(k);
-      let val = obj[camelKey];
-
-      if (val === undefined && obj[dbKey] !== undefined) {
-        val = obj[dbKey];
-      }
-
-      if (val === undefined || val === null) {
-        // nullable, nothing to do here
-        if (field.nullable) {
-          continue;
-        }
-        valid = false;
-        break;
-      }
-      if (!field.valid) {
-        continue;
-      }
-      promises.push(field.valid(val));
-    }
-    if (!valid) {
-      return valid;
-    }
-    const ret = await Promise.all(promises);
-    return ret.every((v) => v);
-  }
-
-  async valid(obj: any): Promise<boolean> {
-    if (this.type.globalType) {
-      const f = __getGlobalSchemaField(this.type.globalType);
-      // list and global type is not valid.
-      if (f) {
-        if (f.valid) {
-          if (
-            JSON.stringify(this.type.listElemType) !==
-            JSON.stringify(f?.type.listElemType)
-          ) {
-            if (this.jsonAsList) {
-              if (!Array.isArray(obj)) {
-                return false;
-              }
-              // @ts-ignore
-              const valid = await Promise.all(obj.map((v) => f.valid(v)));
-              return valid.every((b) => b);
-            } else {
-              return f.valid([obj]);
-            }
-          }
-
-          return f.valid(obj);
-        }
-        return true;
-      } else {
-        log(
-          "error",
-          `globalType ${this.type.globalType} not found in global schema`,
-        );
-        return false;
-      }
-    }
-    if (this.jsonAsList) {
-      if (!Array.isArray(obj)) {
-        return false;
-      }
-      const valid = await Promise.all(obj.map((v) => this.validImpl(v)));
-      return valid.every((b) => b);
-    }
-    if (!(obj instanceof Object)) {
-      return false;
-    }
-
-    return this.validImpl(obj);
-  }
-}
-
-export function StructType(options: StructOptions) {
-  let result = new StructField(options);
-  return Object.assign(result, options);
-}
-
-/**
- * @deprecated use StructTypeAsList
- */
-export function StructListType(options: StructOptions) {
-  return new ListField(StructType(options), options);
-}
-
-export function StructTypeAsList(options: StructOptions) {
-  let result = new StructField(options, true);
-  return Object.assign(result, options);
-}

package/src/schema/union_field.ts

@@ -1,105 +0,0 @@
-import { StructField } from "./struct_field";
-import { FieldOptions, DBType, Type } from "./schema";
-import { BaseField, ListField } from "./field";
-
-export declare type StructMap = {
-  [key: string]: StructField;
-};
-
-// used to know which key in the union is valid.
-// maybe there's a better way of doing this eventually
-const KEY = "___valid___key___";
-
-export interface UnionOptions extends FieldOptions {
-  // required.
-  // how does that jive with https://github.com/lolopinto/ent/issues/609 though??
-  tsType: string;
-  // StructMap enforced in TS here but FieldMap in Type
-  // we want keys because of GraphQL oneOf type
-  fields: StructMap;
-  // if not provided, defaults to tsType
-  graphQLType?: string;
-  jsonNotJSONB?: boolean;
-}
-
-interface validResult {
-  valid: boolean;
-  key: string;
-}
-
-export class UnionField extends BaseField implements FieldOptions {
-  type: Type = {
-    dbType: DBType.JSONB,
-  };
-  m: Map<Object, string> = new Map();
-
-  constructor(private options: UnionOptions) {
-    super();
-    this.type.unionFields = options.fields;
-    this.type.type = options.tsType;
-    this.type.graphQLType = options.graphQLType || options.tsType;
-    // TODO should throw if not nested?
-    if (options.jsonNotJSONB) {
-      this.type.dbType = DBType.JSON;
-    }
-  }
-
-  format(obj: any) {
-    if (!(obj instanceof Object)) {
-      throw new Error("valid was not called");
-    }
-    const k = obj[KEY];
-    if (k === undefined) {
-      throw new Error(`need to call valid first`);
-    }
-    // now delete it since we don't need it anymore
-    delete obj[KEY];
-
-    const field = this.options.fields[k];
-    // always nested for now so pass through
-    return field.format(obj, true);
-  }
-
-  private async validField(k: string, f: StructField, obj: Object) {
-    const valid = await f.valid(obj);
-    return {
-      valid,
-      key: k,
-    };
-  }
-
-  async valid(obj: any): Promise<boolean> {
-    if (!(obj instanceof Object)) {
-      return false;
-    }
-    let promises: Promise<validResult>[] = [];
-
-    for (const k in this.options.fields) {
-      const field = this.options.fields[k];
-      promises.push(this.validField(k, field, obj));
-    }
-    let lastKey: string | undefined;
-    let validCt = 0;
-    const ret = await Promise.all(promises);
-    for (const v of ret) {
-      if (v.valid) {
-        validCt++;
-        lastKey = v.key;
-      }
-    }
-    if (lastKey !== undefined) {
-      obj[KEY] = lastKey;
-    }
-
-    return validCt == 1;
-  }
-}
-
-export function UnionType(options: UnionOptions) {
-  let result = new UnionField(options);
-  return Object.assign(result, options);
-}
-
-export function UnionListType(options: UnionOptions) {
-  return new ListField(UnionType(options), options);
-}

package/src/scripts/custom_compiler.ts

@@ -1,331 +0,0 @@
-#!/usr/bin/env node
-
-import ts from "typescript";
-import * as path from "path";
-import * as glob from "glob";
-import { readCompilerOptions } from "../tsc/compilerOptions";
-
-// TODO this should probably be its own package but for now it's here
-
-class Compiler {
-  private options: ts.CompilerOptions;
-  private regexMap: Map<string, RegExp> = new Map();
-  private cwd: string;
-
-  private resolvers: ((
-    moduleName: string,
-    containingFile: string,
-  ) => ts.ResolvedModule | undefined | null)[] = [];
-
-  constructor(
-    private sourceFiles: string[],
-    private moduleSearchLocations: string[],
-  ) {
-    this.options = readCompilerOptions(".");
-    if (this.options.paths) {
-      for (let key in this.options.paths) {
-        if (key === "*") {
-          continue;
-        }
-        // always make sure it starts at the beginning...
-        this.regexMap.set(key, new RegExp("^" + key, "i"));
-      }
-    }
-    // TODO should be taking baseUrl and using that instead of using cwd and assuming baseUrl == "."
-    this.cwd = process.cwd();
-
-    // set resolvers
-    this.resolvers = [
-      // standard
-      this.standardModules.bind(this),
-
-      // resolvePaths based on tsconfig's paths
-      this.resolvePaths.bind(this),
-
-      // use node or other location paths
-      this.otherLocations.bind(this),
-    ];
-  }
-
-  private standardModules(moduleName: string, containingFile: string) {
-    let result = ts.resolveModuleName(
-      moduleName,
-      containingFile,
-      this.options,
-      {
-        fileExists: ts.sys.fileExists,
-        readFile: ts.sys.readFile,
-      },
-    );
-    return result.resolvedModule;
-  }
-
-  private resolvePaths(
-    moduleName: string,
-    _containingFile: string,
-  ): ts.ResolvedModule | undefined {
-    //      console.log("resolvePaths", moduleName);
-    if (!this.options.paths) {
-      return undefined;
-    }
-
-    let paths = this.options.paths;
-    for (let key in paths) {
-      let r = this.regexMap.get(key);
-      if (!r) {
-        continue;
-      }
-      let value = paths[key];
-
-      if (r.test(moduleName)) {
-        // substitute...
-        // can this be more than one?
-        // not for now...
-        let str = value[0];
-        let lastIdx = value[0].lastIndexOf("*");
-        if (lastIdx === -1) {
-          console.error("incorrectly formatted regex");
-          continue;
-        }
-        str = str.substr(0, lastIdx);
-        let resolvedFileName =
-          path.join(this.cwd, moduleName.replace(r, str)) + ".ts";
-        //          console.log(resolvedFileName);
-        return {
-          resolvedFileName,
-        };
-      }
-    }
-    return undefined;
-  }
-
-  private otherLocations(moduleName: string, _containingFile: string) {
-    for (const location of this.moduleSearchLocations) {
-      const modulePath = path.join(location, moduleName + ".d.ts");
-      if (ts.sys.fileExists(modulePath)) {
-        return { resolvedFileName: modulePath };
-      }
-    }
-    return undefined;
-  }
-
-  private createCompilerHost(): ts.CompilerHost {
-    return {
-      getSourceFile: this.getSourceFile,
-      getDefaultLibFileName: () => "lib.d.ts",
-      writeFile: (fileName, content) => ts.sys.writeFile(fileName, content),
-      getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
-      getDirectories: (path) => ts.sys.getDirectories(path),
-      getCanonicalFileName: (fileName) =>
-        ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
-      getNewLine: () => ts.sys.newLine,
-      useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
-      fileExists: ts.sys.fileExists,
-      readFile: ts.sys.readFile,
-      resolveModuleNames: (
-        moduleNames: string[],
-        containingFile: string,
-        _reusedNames: string[] | undefined,
-        _redirectedReference: ts.ResolvedProjectReference | undefined,
-        _options: ts.CompilerOptions,
-      ) => {
-        return this.resolveModuleNames(moduleNames, containingFile);
-      },
-    };
-  }
-
-  private getSourceFile(
-    fileName: string,
-    languageVersion: ts.ScriptTarget,
-    onError?: (message: string) => void,
-  ) {
-    const sourceText = ts.sys.readFile(fileName);
-    return sourceText !== undefined
-      ? ts.createSourceFile(fileName, sourceText, languageVersion)
-      : undefined;
-  }
-
-  // this is not enough because it doesn't solve the outputted file?
-  private resolveModuleNames(
-    moduleNames: string[],
-    containingFile: string,
-  ): (ts.ResolvedModule | undefined)[] {
-    // go through each moduleName and resolvers in order to see if we find what we're looking for
-    let resolvedModules: (ts.ResolvedModule | undefined)[] = [];
-    for (const moduleName of moduleNames) {
-      // undefined is valid
-      let resolved: ts.ResolvedModule | undefined;
-      for (const resolver of this.resolvers) {
-        let result = resolver(moduleName, containingFile);
-        // yay!
-        if (result) {
-          resolved = result;
-          break;
-        }
-      }
-      resolvedModules.push(resolved);
-    }
-
-    return resolvedModules;
-  }
-
-  private transformer(context: ts.TransformationContext) {
-    let cwd = this.cwd;
-    let paths = this.options.paths;
-    let regexMap = this.regexMap;
-    return function (node: ts.SourceFile) {
-      // don't do anything with declaration files
-      // nothing to do here
-      if (node.isDeclarationFile) {
-        return node;
-      }
-
-      // no paths, nothing to do heree
-      if (!paths) {
-        return node;
-      }
-
-      let fullPath: string;
-      if (path.isAbsolute(node.fileName)) {
-        fullPath = node.fileName;
-      } else {
-        fullPath = path.join(cwd, node.fileName);
-      }
-      // don't care about paths not relative to cwd since we can't handle that...
-      let relativePath = path.relative(cwd, fullPath);
-      if (relativePath.startsWith("..")) {
-        return node;
-      }
-
-      function checkPath(
-        paths: ts.MapLike<string[]> | undefined,
-        text: string,
-      ): string | undefined {
-        // remove quotes
-        text = text.slice(1, -1);
-        let relPath: string | undefined;
-
-        for (const key in paths) {
-          let r = regexMap.get(key);
-          if (!r) {
-            continue;
-          }
-          let value = paths[key];
-          let str = value[0];
-
-          if (!r.test(text)) {
-            continue;
-          }
-          let idx = text.indexOf("/");
-          let strIdx = str.indexOf("*");
-          if (idx === -1 || strIdx === -1) {
-            continue;
-          }
-          relPath = path.relative(
-            // just because of how imports work. it's relative from directory not current path
-            path.dirname(fullPath),
-            path.join(
-              text.substring(0, idx).replace(r, str.substring(0, strIdx)),
-              text.substring(idx),
-            ),
-          );
-          // if file ends with "..", we've reached a case where we're trying to
-          // import something like foo/contact(.ts) from within foo/contact/bar/baz/page.ts
-          // and we're confused about it so we need to detect that case and handle it
-          if (relPath.endsWith("..")) {
-            // there's an actual local file here not root of directory, try that instead
-            // (if root of directory and there's ambiguity, we should use "contact/")
-            if (ts.sys.fileExists(text + ".ts")) {
-              let text2 = text + ".ts";
-              relPath = path.relative(
-                // just because of how imports work. it's relative from directory not current path
-                path.dirname(fullPath),
-                path.join(
-                  text2.substring(0, idx).replace(r, str.substring(0, strIdx)),
-                  text2.substring(idx),
-                ),
-              );
-            }
-          }
-          if (!relPath.startsWith("..")) {
-            relPath = "./" + relPath;
-          }
-
-          // tsc removes this by default so we need to also do it
-          let tsIdx = relPath.indexOf(".ts");
-          if (tsIdx !== -1) {
-            relPath = relPath.substring(0, tsIdx);
-          }
-          return relPath;
-        }
-      }
-
-      function visitor(node: ts.Node) {
-        if (node.kind === ts.SyntaxKind.ImportDeclaration) {
-          let importNode = node as ts.ImportDeclaration;
-
-          let text = importNode.moduleSpecifier.getText();
-          let relPath = checkPath(paths, text);
-          if (relPath) {
-            // update the node...
-            return ts.factory.updateImportDeclaration(
-              importNode,
-              importNode.modifiers,
-              importNode.importClause,
-              ts.factory.createStringLiteral(relPath),
-              importNode.assertClause,
-            );
-          }
-        }
-        if (node.kind === ts.SyntaxKind.ExportDeclaration) {
-          let exportNode = node as ts.ExportDeclaration;
-
-          let text = exportNode.moduleSpecifier?.getText();
-
-          if (text) {
-            let relPath = checkPath(paths, text);
-            if (relPath) {
-              // update the node...
-              return ts.factory.updateExportDeclaration(
-                exportNode,
-                exportNode.modifiers,
-                exportNode.isTypeOnly,
-                exportNode.exportClause,
-                ts.factory.createStringLiteral(relPath),
-                exportNode.assertClause,
-              );
-            }
-          }
-        }
-        return node;
-      }
-
-      return ts.visitEachChild(node, visitor, context);
-    };
-  }
-
-  compile(): void {
-    const host = this.createCompilerHost();
-    const program = ts.createProgram(this.sourceFiles, this.options, host);
-    let emitResult = program.emit(undefined, undefined, undefined, undefined, {
-      before: [this.transformer.bind(this)],
-    });
-    if (emitResult.emitSkipped) {
-      console.error("error emitting code");
-    }
-
-    let exitCode = emitResult.emitSkipped ? 1 : 0;
-    process.exit(exitCode);
-  }
-}
-
-// let's use a glob from current directory
-// todo this should be configurable
-// TODO this should be broken into its own repo and npm module
-// TODO use includes and exclude in tsconfig.json if it exists
-new Compiler(
-  glob.sync("**/*.ts", {
-    ignore: ["node_modules/**", "tests/**", "**/*.test.ts"],
-  }),
-  ["node_modules/@types/node"],
-).compile();