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

package/src/testutils/test_edge_global_schema.ts

@@ -1,49 +0,0 @@
-import {
-  SQLStatementOperation,
-  TimestampType,
-  EdgeUpdateOperation,
-  TransformedEdgeUpdateOperation,
-} from "../schema";
-import * as clause from "../core/clause";
-import { AssocEdge } from "../core/ent";
-import { Data } from "../core/base";
-
-export class EdgeWithDeletedAt extends AssocEdge {
-  deletedAt: Date | null;
-
-  constructor(data: Data) {
-    super(data);
-    this.deletedAt = data.deleted_at;
-  }
-}
-
-export const testEdgeGlobalSchema = {
-  extraEdgeFields: {
-    // need this to be lowerCamelCase because we do this based on field name
-    // #510
-    deletedAt: TimestampType({
-      nullable: true,
-      index: true,
-      defaultValueOnCreate: () => null,
-    }),
-  },
-
-  transformEdgeRead(): clause.Clause {
-    return clause.Eq("deleted_at", null);
-  },
-
-  transformEdgeWrite(
-    stmt: EdgeUpdateOperation,
-  ): TransformedEdgeUpdateOperation | null {
-    switch (stmt.op) {
-      case SQLStatementOperation.Delete:
-        return {
-          op: SQLStatementOperation.Update,
-          data: {
-            deleted_at: new Date(),
-          },
-        };
-    }
-    return null;
-  },
-};

package/src/testutils/write.ts

@@ -1,70 +0,0 @@
-import {
-  EditRowOptions,
-  Data,
-  DataOptions,
-  CreateRowOptions,
-} from "../core/base";
-import {
-  createRow,
-  editRow,
-  deleteRows,
-  createRowSync,
-  editRowSync,
-  deleteRowsSync,
-} from "../core/ent";
-import * as clause from "../core/clause";
-import DB, { Client, Dialect, SyncClient } from "../core/db";
-
-function isSyncClient(client: Client): client is SyncClient {
-  return (client as SyncClient).execSync !== undefined;
-}
-
-export async function createRowForTest(
-  options: CreateRowOptions,
-  suffix?: string,
-): Promise<Data | null> {
-  let client: Client;
-  if (Dialect.SQLite === DB.getDialect()) {
-    client = DB.getInstance().getSQLiteClient();
-  } else {
-    client = await DB.getInstance().getNewClient();
-  }
-
-  try {
-    if (isSyncClient(client)) {
-      return createRowSync(client, options, suffix || "");
-    }
-    return await createRow(client, options, suffix || "");
-  } finally {
-    client.release();
-  }
-}
-
-export async function editRowForTest(options: EditRowOptions, suffix?: string) {
-  const client = await DB.getInstance().getNewClient();
-
-  try {
-    if (isSyncClient(client)) {
-      return editRowSync(client, options, suffix || "");
-    }
-    return await editRow(client, options, suffix);
-  } finally {
-    client.release();
-  }
-}
-
-export async function deleteRowsForTest(
-  options: DataOptions,
-  cls: clause.Clause,
-) {
-  const client = await DB.getInstance().getNewClient();
-
-  try {
-    if (isSyncClient(client)) {
-      return deleteRowsSync(client, options, cls);
-    }
-    return await deleteRows(client, options, cls);
-  } finally {
-    client.release();
-  }
-}

package/src/tsc/ast.ts

@@ -1,351 +0,0 @@
-import { Data } from "../core/base";
-import ts from "typescript";
-import * as path from "path";
-import { load } from "js-yaml";
-import { ConfigWithCodegen } from "../core/config";
-import * as fs from "fs";
-import { PACKAGE } from "../core/const";
-
-export function getPreText(
-  fileContents: string,
-  node: ts.Node,
-  sourceFile: ts.SourceFile,
-): string {
-  return fileContents.substring(node.getFullStart(), node.getStart(sourceFile));
-}
-
-export interface ClassInfo {
-  extends?: string;
-  comment: string;
-  name: string;
-  export?: boolean;
-  default?: boolean;
-  //  implementsSchema?: boolean;
-  implements?: string[];
-  wrapClassContents(inner: string): string;
-}
-
-export function getClassInfo(
-  fileContents: string,
-  sourceFile: ts.SourceFile,
-  node: ts.ClassDeclaration,
-): ClassInfo | undefined {
-  let className = node.name?.text;
-
-  let classExtends: string | undefined;
-  let impl: string[] = [];
-  if (node.heritageClauses) {
-    for (const hc of node.heritageClauses) {
-      switch (hc.token) {
-        case ts.SyntaxKind.ImplementsKeyword:
-          for (const type of hc.types) {
-            impl.push(type.expression.getText(sourceFile));
-          }
-          break;
-
-        case ts.SyntaxKind.ExtendsKeyword:
-          // can only extend one class
-          for (const type of hc.types) {
-            const text = type.expression.getText(sourceFile);
-            classExtends = text;
-          }
-          break;
-      }
-    }
-  }
-
-  if (!className) {
-    return undefined;
-  }
-
-  let hasExport = false;
-  let hasDefault = false;
-  let comment = getPreText(fileContents, node, sourceFile);
-
-  const wrapClassContents = (inner: string) => {
-    let ret = `${comment}`;
-    if (hasExport) {
-      ret += "export ";
-    }
-    if (hasDefault) {
-      ret += "default ";
-    }
-    ret += `class ${className} `;
-    if (classExtends) {
-      ret += `extends ${classExtends} `;
-    }
-    if (impl.length) {
-      ret += `implements ${impl.join(", ")}`;
-    }
-
-    return `${ret}{
-      ${inner}
-    }`;
-  };
-
-  if (node.modifiers) {
-    for (const mod of node.modifiers) {
-      const text = mod.getText(sourceFile);
-      if (text === "export") {
-        hasExport = true;
-      } else if (text === "default") {
-        hasDefault = true;
-      }
-    }
-  }
-
-  return {
-    name: className,
-    extends: classExtends,
-    comment,
-    implements: impl,
-    wrapClassContents,
-    export: hasExport,
-    default: hasDefault,
-  };
-}
-
-type transformImportFn = (imp: string) => string;
-
-interface transformOpts {
-  removeImports?: string[];
-  newImports?: string[];
-  transform?: transformImportFn;
-  transformPath: string;
-}
-
-export function transformImport(
-  fileContents: string,
-  importNode: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-  opts: transformOpts,
-): string | undefined {
-  // remove quotes too
-  const text = importNode.moduleSpecifier.getText(sourceFile).slice(1, -1);
-  if (text != opts.transformPath) {
-    return;
-  }
-
-  const impInfo = getImportInfo(importNode, sourceFile);
-  if (!impInfo) {
-    return;
-  }
-  let { imports, start, end, importText, default: def } = impInfo;
-
-  let removeImportsMap: Data = {};
-  if (opts?.removeImports) {
-    opts.removeImports.forEach((imp) => {
-      removeImportsMap[imp] = true;
-      if (def === imp) {
-        def = "";
-      }
-    });
-  }
-  let finalImports = new Set<string>();
-
-  for (let i = 0; i < imports.length; i++) {
-    let imp = imports[i].trim();
-    if (imp === "") {
-      continue;
-    }
-    if (opts?.transform) {
-      imp = opts.transform(imp);
-    }
-    if (removeImportsMap[imp]) {
-      continue;
-    }
-    finalImports.add(imp);
-  }
-  if (opts?.newImports) {
-    opts.newImports.forEach((imp) => finalImports.add(imp));
-  }
-
-  const comment = getPreText(fileContents, importNode, sourceFile);
-
-  if (!finalImports.size) {
-    return;
-  }
-
-  return (
-    comment +
-    "import " +
-    // add default
-    (def || "") +
-    // should probably always be "{" now that we support default
-    (start >= 0 ? importText.substring(0, start + 1) : "{") +
-    Array.from(finalImports).join(", ") +
-    // should probably always be "}"
-    (end >= 0 ? importText.substring(end) : "}") +
-    ' from "' +
-    text +
-    '";'
-  );
-}
-
-export function updateImportPath(
-  fileContents: string,
-  importNode: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-  newPath: string,
-) {
-  const comment = getPreText(fileContents, importNode, sourceFile);
-
-  // all this copied from above...
-  const importText = importNode.importClause?.getText(sourceFile) || "";
-  const start = importText.indexOf("{");
-  const end = importText.lastIndexOf("}");
-  if (start === -1 || end === -1) {
-    return;
-  }
-  const imports = importText
-    .substring(start + 1, end)
-    //    .trim()
-    .split(",");
-
-  return (
-    comment +
-    "import " +
-    importText.substring(0, start + 1) +
-    Array.from(imports).join(", ") +
-    importText.substring(end) +
-    ' from "' +
-    newPath +
-    '";'
-  );
-}
-
-export function isRelativeImport(
-  node: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-) {
-  const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
-  return text.startsWith("..") || text.startsWith("./");
-}
-
-export function isRelativeGeneratedImport(
-  node: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-) {
-  const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
-  return (
-    (text.startsWith("..") || text.startsWith("./")) &&
-    text.indexOf("/generated") !== -1
-  );
-}
-
-export function isSrcGeneratedImport(
-  node: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-) {
-  const text = node.moduleSpecifier.getText(sourceFile).slice(1, -1);
-  return text.startsWith("src") && text.includes("/generated");
-}
-
-interface importInfo {
-  imports: string[];
-  start: number;
-  end: number;
-  importText: string;
-  importPath: string;
-  default?: string;
-}
-
-// TODO doesn't support default + {} yet
-export function getImportInfo(
-  imp: ts.ImportDeclaration,
-  sourceFile: ts.SourceFile,
-): importInfo | undefined {
-  const importText = imp.importClause?.getText(sourceFile) || "";
-  const start = importText.indexOf("{");
-  const end = importText.lastIndexOf("}");
-  const text = imp.moduleSpecifier.getText(sourceFile).slice(1, -1);
-
-  if ((start === -1 || end === -1) && !importText.length) {
-    return;
-  }
-  let imports: string[] = [];
-  let def: string | undefined;
-  if (start !== -1 && end !== -1) {
-    imports = importText
-      .substring(start + 1, end)
-      //.trim()
-      .split(",");
-  } else {
-    def = importText;
-  }
-
-  return {
-    importPath: text,
-    importText,
-    start,
-    end,
-    imports,
-    default: def,
-  };
-}
-
-export function transformRelative(
-  file: string,
-  importPath: string,
-  relative?: boolean,
-): string {
-  if (!relative || !importPath.startsWith("src")) {
-    return importPath;
-  }
-
-  const fileFullPath = path.join(process.cwd(), file);
-  const impFullPath = path.join(process.cwd(), importPath);
-  // relative path is from directory
-  return normalizePath(path.relative(path.dirname(fileFullPath), impFullPath));
-}
-
-function normalizePath(p: string) {
-  if (p.endsWith("..")) {
-    return p + "/";
-  }
-  if (!p.startsWith("..")) {
-    return "./" + p;
-  }
-  return p;
-}
-
-export interface customInfo {
-  viewerInfo: {
-    path: string;
-    name: string;
-  };
-  relativeImports?: boolean;
-  globalSchemaPath?: string;
-}
-
-// also used in parse schema logic
-export function getCustomInfo(): customInfo {
-  let yaml: ConfigWithCodegen | undefined = {};
-
-  let relativeImports = false;
-  try {
-    yaml = load(
-      fs.readFileSync(path.join(process.cwd(), "ent.yml"), {
-        encoding: "utf8",
-      }),
-    ) as ConfigWithCodegen;
-
-    relativeImports = yaml?.codegen?.relativeImports || false;
-
-    if (yaml?.codegen?.templatizedViewer) {
-      return {
-        viewerInfo: yaml.codegen.templatizedViewer,
-        relativeImports,
-        globalSchemaPath: yaml.globalSchemaPath,
-      };
-    }
-  } catch (e) {}
-  return {
-    viewerInfo: {
-      path: PACKAGE,
-      name: "Viewer",
-    },
-    relativeImports,
-    globalSchemaPath: yaml.globalSchemaPath,
-  };
-}

package/src/tsc/compilerOptions.ts

@@ -1,85 +0,0 @@
-import * as fs from "fs";
-import JSON5 from "json5";
-import ts from "typescript";
-import * as path from "path";
-
-function findTSConfigFile(filePath: string): string | null {
-  while (filePath != "/") {
-    let configPath = `${filePath}/tsconfig.json`;
-    if (fs.existsSync(configPath)) {
-      return configPath;
-    }
-    filePath = path.join(filePath, "..");
-  }
-  return null;
-}
-
-export function readCompilerOptions(filePath: string) {
-  let configPath = findTSConfigFile(filePath);
-  if (!configPath) {
-    return {};
-  }
-
-  let json: any = {};
-  try {
-    json = JSON5.parse(
-      fs.readFileSync(configPath, {
-        encoding: "utf8",
-      }),
-    );
-  } catch (e) {
-    console.error("couldn't read tsconfig.json file");
-  }
-  let options: ts.CompilerOptions = json["compilerOptions"] || {};
-  // @ts-ignore
-  if (options.moduleResolution === "node") {
-    options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
-  }
-  return options;
-}
-
-export function getTarget(target?: string): ts.ScriptTarget {
-  switch (target?.toLowerCase()) {
-    case "es2015":
-      return ts.ScriptTarget.ES2015;
-    case "es2016":
-      return ts.ScriptTarget.ES2016;
-    case "es2017":
-      return ts.ScriptTarget.ES2017;
-    case "es2018":
-      return ts.ScriptTarget.ES2018;
-    case "es2019":
-      return ts.ScriptTarget.ES2019;
-    case "es2020":
-      return ts.ScriptTarget.ES2020;
-    case "es2021":
-      return ts.ScriptTarget.ES2021;
-    case "es3":
-      return ts.ScriptTarget.ES3;
-    case "es5":
-      return ts.ScriptTarget.ES5;
-    case "esnext":
-      return ts.ScriptTarget.ESNext;
-    default:
-      return ts.ScriptTarget.ESNext;
-  }
-}
-
-export function getTargetFromCurrentDir(): ts.ScriptTarget {
-  const options = readCompilerOptions(".");
-  return getTarget(options.target?.toString());
-}
-
-export function createSourceFile(target: ts.ScriptTarget, file: string) {
-  let contents = fs.readFileSync(file).toString();
-
-  // go through the file and print everything back if not starting immediately after other position
-  const sourceFile = ts.createSourceFile(
-    file,
-    contents,
-    target,
-    false,
-    ts.ScriptKind.TS,
-  );
-  return { contents, sourceFile };
-}