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

package/src/index.ts

@@ -0,0 +1,145 @@
+export * from "./core/base";
+export {
+  loadEnt,
+  loadCustomData,
+  loadCustomEnts,
+  loadCustomCount,
+  loadEntX,
+  loadEnts,
+  CustomQuery,
+  loadDerivedEnt,
+  loadDerivedEntX,
+  loadEntViaKey,
+  loadEntXViaKey,
+  performRawQuery,
+  // even these 3 need to change...
+  loadRowX,
+  loadRow,
+  loadRows,
+  AssocEdge,
+  AssocEdgeData,
+  loadEdgeData,
+  loadEdgeDatas,
+  loadEdges,
+  loadUniqueEdge,
+  loadUniqueNode,
+  loadRawEdgeCountX,
+  loadEdgeForID2,
+  loadNodesByEdge,
+  getEdgeTypeInGroup,
+} from "./core/ent";
+// TODO should these even be exported from the root?
+export {
+  DataOperation,
+  EditNodeOptions,
+  EditNodeOperation,
+  RawQueryOperation,
+  EdgeOperation,
+  DeleteNodeOperation,
+  AssocEdgeInputOptions,
+  AssocEdgeInput,
+} from "./action/operations";
+export { setGlobalSchema } from "./core/global_schema";
+import DB from "./core/db";
+export * from "./core/loaders";
+export { DB };
+
+// TODO figure out if this should be its own import path e.g. @snowtop/ent/privacy
+export {
+  EntPrivacyError,
+  AlwaysAllowRule,
+  AlwaysDenyRule,
+  DenyIfLoggedInRule,
+  DenyIfLoggedOutRule,
+  AllowIfHasIdentity,
+  AllowIfViewerRule,
+  AllowIfFuncRule,
+  AllowIfViewerIsRule,
+  AllowIfViewerIsEntPropertyRule,
+  AllowIfEntPropertyIsRule,
+  DenyIfEntPropertyIsRule,
+  AllowIfViewerEqualsRule,
+  DenyIfViewerEqualsRule,
+  AllowIfEdgeExistsRule,
+  AllowIfViewerInboundEdgeExistsRule,
+  AllowIfViewerOutboundEdgeExistsRule,
+  DenyIfEdgeExistsRule,
+  DenyIfViewerInboundEdgeExistsRule,
+  DenyIfViewerOutboundEdgeExistsRule,
+  DenyIfEdgeDoesNotExistRule,
+  DenyIfViewerInboundEdgeDoesNotExistRule,
+  DenyIfViewerOutboundEdgeDoesNotExistRule,
+  AllowIfEntIsVisibleRule,
+  AllowIfEntIsNotVisibleRule,
+  DenyIfEntIsVisibleRule,
+  DenyIfEntIsNotVisibleRule,
+  AllowIfEntIsVisiblePolicy,
+  DenyIfEntIsVisiblePolicy,
+  DelayedResultRule,
+  applyPrivacyPolicy,
+  applyPrivacyPolicyX,
+  AlwaysAllowPrivacyPolicy,
+  AlwaysDenyPrivacyPolicy,
+  AllowIfConditionAppliesRule,
+  AllowIfSubPolicyAllowsRule,
+  AllowIfViewerPrivacyPolicy,
+  AllowIfViewerHasIdentityPrivacyPolicy,
+} from "./core/privacy";
+export * from "./core/query";
+export * from "./core/query_impl";
+
+export * from "./schema/";
+import * as q from "./core/clause";
+export { Clause } from "./core/clause";
+const query = {
+  Eq: q.Eq,
+  NotEq: q.NotEq,
+  And: q.And,
+  AndOptional: q.AndOptional,
+  Or: q.Or,
+  OrOptional: q.OrOptional,
+  In: q.In,
+  UuidIn: q.UuidIn,
+  IntegerIn: q.IntegerIn,
+  TextIn: q.TextIn,
+  DBTypeIn: q.DBTypeIn,
+  UuidNotIn: q.UuidNotIn,
+  IntegerNotIn: q.IntegerNotIn,
+  TextNotIn: q.TextNotIn,
+  DBTypeNotIn: q.DBTypeNotIn,
+  Greater: q.Greater,
+  Less: q.Less,
+  GreaterEq: q.GreaterEq,
+  LessEq: q.LessEq,
+  ArrayEq: q.ArrayEq,
+  ArrayNotEq: q.ArrayNotEq,
+  PostgresArrayContainsValue: q.PostgresArrayContainsValue,
+  PostgresArrayContains: q.PostgresArrayContains,
+  PostgresArrayNotContainsValue: q.PostgresArrayNotContainsValue,
+  PostgresArrayNotContains: q.PostgresArrayNotContains,
+  PostgresArrayOverlaps: q.PostgresArrayOverlaps,
+  PostgresArrayNotOverlaps: q.PostgresArrayNotOverlaps,
+  JSONPathValuePredicate: q.JSONPathValuePredicate,
+  JSONObjectFieldKeyASJSON: q.JSONObjectFieldKeyASJSON,
+  JSONObjectFieldKeyAsText: q.JSONObjectFieldKeyAsText,
+  TsQuery: q.TsQuery,
+  PlainToTsQuery: q.PlainToTsQuery,
+  PhraseToTsQuery: q.PhraseToTsQuery,
+  WebsearchToTsQuery: q.WebsearchToTsQuery,
+  TsVectorColTsQuery: q.TsVectorColTsQuery,
+  TsVectorPlainToTsQuery: q.TsVectorPlainToTsQuery,
+  TsVectorPhraseToTsQuery: q.TsVectorPhraseToTsQuery,
+  TsVectorWebsearchToTsQuery: q.TsVectorWebsearchToTsQuery,
+};
+
+export { query };
+
+export { RequestContext, ContextCache } from "./core/context";
+
+export { IDViewer, LoggedOutViewer, IDViewerOptions } from "./core/viewer";
+
+export { loadConfig } from "./core/config";
+
+export { setLogLevels } from "./core/logger";
+
+export * from "./core/convert";

package/src/parse_schema/parse.ts

@@ -0,0 +1,585 @@
+import { cosmiconfigSync } from "cosmiconfig";
+import { PACKAGE } from "../core/const";
+import {
+  Pattern,
+  Schema,
+  Field,
+  AssocEdge,
+  AssocEdgeGroup,
+  Action,
+  EdgeAction,
+} from "../schema";
+import {
+  ActionField,
+  Type,
+  FieldMap,
+  GlobalSchema,
+  TransformReadBetaResult,
+  CanViewerDo,
+  EdgeGroupAction,
+} from "../schema/schema";
+import { setGlobalSchema } from "../core/global_schema";
+
+export async function processFields(
+  src: FieldMap | Field[],
+  patternName?: string,
+): Promise<ProcessedField[]> {
+  const ret: ProcessedField[] = [];
+  let m: FieldMap = {};
+  if (Array.isArray(src)) {
+    for (const field of src) {
+      const name = field.name;
+      if (!name) {
+        throw new Error(`name is required`);
+      }
+      m[name] = field;
+    }
+  } else {
+    m = src;
+  }
+  for (const name in m) {
+    const field = m[name];
+    //@ts-ignore type and other changed fields with different type in ProcessedField vs Field
+    let f: ProcessedField = { ...field, name };
+    f.hasDefaultValueOnCreate = field.defaultValueOnCreate != undefined;
+    f.hasDefaultValueOnEdit = field.defaultValueOnEdit != undefined;
+    f.hasFieldPrivacy = field.privacyPolicy !== undefined;
+    f.hasEditFieldPrivacy = field.editPrivacyPolicy !== undefined;
+    if (field.polymorphic) {
+      // convert boolean into object
+      // we keep boolean as an option to keep API simple
+      if (typeof field.polymorphic === "boolean") {
+        f.polymorphic = {};
+      } else {
+        f.polymorphic = field.polymorphic;
+      }
+    } else {
+      delete f.polymorphic;
+    }
+    if (field.private) {
+      // convert boolean into object
+      // we keep boolean as an option to keep API simple
+      if (typeof field.private === "boolean") {
+        f.private = {};
+      } else {
+        f.private = field.private;
+      }
+    } else {
+      delete f.private;
+    }
+    // convert string to object to make API consumed by go simple
+    if (f.fieldEdge && f.fieldEdge.inverseEdge) {
+      if (typeof f.fieldEdge.inverseEdge === "string") {
+        f.fieldEdge.inverseEdge = {
+          name: f.fieldEdge.inverseEdge,
+        };
+      }
+    }
+    if (patternName) {
+      f.patternName = patternName;
+    }
+    if (field.serverDefault !== undefined) {
+      f.serverDefault = await transformServerDefault(
+        name,
+        field,
+        field.serverDefault,
+      );
+    }
+
+    transformType(field.type);
+
+    if (field.getDerivedFields) {
+      f.derivedFields = await processFields(field.getDerivedFields(name));
+    }
+    if (field.type.subFields) {
+      f.type.subFields = await processFields(field.type.subFields);
+    }
+    if (field.type.unionFields) {
+      f.type.unionFields = await processFields(field.type.unionFields);
+    }
+    if (
+      field.type.listElemType &&
+      field.type.listElemType.subFields &&
+      // check to avoid ts-ignore below. exists just for tsc
+      f.type.listElemType
+    ) {
+      f.type.listElemType.subFields = await processFields(
+        field.type.listElemType.subFields,
+      );
+    }
+    ret.push(f);
+  }
+  return ret;
+}
+
+async function transformServerDefault(name: string, f: Field, value: any) {
+  if (f.valid) {
+    if (!(await f.valid(value))) {
+      throw new Error(`invalid value ${value} passed to field ${name}`);
+    }
+  }
+  if (f.format) {
+    value = await f.format(value);
+  }
+  switch (typeof value) {
+    case "boolean":
+    case "number":
+    case "bigint":
+    case "string":
+      return `${value}`;
+    default:
+      throw new Error(`invalid value ${value} passed to field ${name}`);
+  }
+}
+
+function transformImportType(typ: Type) {
+  if (!typ.importType) {
+    return;
+  }
+  typ.importType = {
+    ...typ.importType,
+    // these 2 needed for forwards compatibility with new go schema
+    importPath: typ.importType.path,
+    import: typ.importType.type,
+  };
+}
+
+function transformType(typ: Type | undefined) {
+  if (!typ) {
+    return;
+  }
+  transformImportType(typ);
+  transformType(typ.listElemType);
+}
+
+function processEdges(
+  src: AssocEdge[],
+  patternName?: string,
+): ProcessedAssocEdge[] {
+  const ret: ProcessedAssocEdge[] = [];
+  for (const edge of src) {
+    let edge2 = { ...edge } as ProcessedAssocEdge;
+    edge2.edgeActions = edge.edgeActions?.map((action) =>
+      processAction(action),
+    );
+    edge2.patternName = patternName;
+    ret.push(edge2);
+  }
+  return ret;
+}
+
+function processEdgeGroups(
+  processedSchema: ProcessedSchema,
+  edgeGroups: AssocEdgeGroup[],
+) {
+  // array-ify this
+  for (const group of edgeGroups) {
+    if (group.nullStates && !Array.isArray(group.nullStates)) {
+      group.nullStates = [group.nullStates];
+    }
+    let group2 = { ...group } as ProcessedAssocEdgeGroup;
+    if (group.edgeAction) {
+      group2.edgeAction = processAction(group.edgeAction);
+    }
+    processedSchema.assocEdgeGroups.push(group2);
+  }
+}
+
+async function processPattern(
+  patterns: patternsDict,
+  pattern: Pattern,
+  processedSchema: ProcessedSchema,
+): Promise<TransformFlags> {
+  let ret: TransformFlags = {
+    ...pattern,
+  };
+  const name = pattern.name;
+  const fields = await processFields(pattern.fields, pattern.name);
+  processedSchema.fields.push(...fields);
+  if (pattern.edges) {
+    const edges = processEdges(pattern.edges, pattern.name);
+    processedSchema.assocEdges.push(...edges);
+  }
+
+  // flag transformsSelect
+  if (pattern.transformRead) {
+    ret.transformsSelect = true;
+
+    if (pattern.transformReadCodegen_BETA) {
+      const r = pattern.transformReadCodegen_BETA();
+      if (typeof r === "string") {
+        ret.transformsLoaderCodegen = {
+          code: r,
+          imports: [
+            {
+              importPath: PACKAGE,
+              import: "query",
+            },
+          ],
+        };
+      } else {
+        ret.transformsLoaderCodegen = r;
+      }
+    }
+  }
+
+  if (patterns[name] === undefined) {
+    // intentionally processing separately and not passing pattern.name
+    const edges = processEdges(pattern.edges || []);
+    patterns[name] = {
+      name: pattern.name,
+      assocEdges: edges,
+      fields: fields,
+      disableMixin: pattern.disableMixin,
+    };
+  } else {
+    // TODO ideally we want to make sure that different patterns don't have the same name
+    // can't do a deepEqual check because function calls and therefore different instances in fields
+  }
+  return ret;
+}
+
+enum NullableResult {
+  CONTENTS = "contents",
+  CONTENTS_AND_LIST = "contentsAndList",
+  ITEM = "true", // nullable = true
+}
+
+type ProcessedActionField = Omit<ActionField, "nullable"> & {
+  nullable?: NullableResult;
+};
+
+type ProcessedAssocEdge = Omit<
+  AssocEdge,
+  "actionOnlyFields" | "edgeActions"
+> & {
+  // indicates edge is part of a pattern and should reference that pattern
+  // e.g. use pattern's const, pattern edgequery base class etc
+  // set via framework
+  patternName?: string;
+  edgeActions?: OutputAction[];
+};
+
+interface TransformFlags {
+  // we don't necessary use all of the below but we flag it for now
+  // in case we end up using it in the future
+  // we only care
+  // meaning there needs to be a way to load without transformation
+  transformsSelect?: boolean;
+  // meaning there needs to be a way to actually delete
+  transformsDelete?: boolean;
+
+  transformsLoaderCodegen?: TransformReadBetaResult;
+
+  transformsInsert?: boolean;
+  transformsUpdate?: boolean;
+}
+
+type ProcessedSchema = Omit<
+  Schema,
+  "edges" | "actions" | "edgeGroups" | "fields"
+> &
+  TransformFlags & {
+    actions: OutputAction[];
+    assocEdges: ProcessedAssocEdge[];
+    assocEdgeGroups: ProcessedAssocEdgeGroup[];
+    // converting to list for go because we want the order respected
+    // and go maps don't support order
+
+    fields: ProcessedField[];
+
+    schemaPath?: string;
+    patternNames?: string[];
+  };
+
+type ProcessedAssocEdgeGroup = Omit<AssocEdgeGroup, "edgeAction"> & {
+  edgeAction?: OutputAction;
+};
+
+type OutputAction = Omit<Action, "actionOnlyFields" | "canViewerDo"> & {
+  actionOnlyFields?: ProcessedActionField[];
+  canViewerDo?: CanViewerDo;
+};
+
+function processAction(
+  action: Action | EdgeAction | EdgeGroupAction,
+): OutputAction {
+  const ret = { ...action } as OutputAction;
+  if (action.actionOnlyFields !== undefined) {
+    let actionOnlyFields: ProcessedActionField[] = action.actionOnlyFields.map(
+      (f) => {
+        let f2 = f as ProcessedActionField;
+        if (!f.nullable) {
+          delete f2.nullable;
+          return f2;
+        }
+        if (typeof f.nullable === "boolean") {
+          f2.nullable = NullableResult.ITEM;
+        } else {
+          if (f.nullable === "contentsAndList") {
+            f2.nullable = NullableResult.CONTENTS_AND_LIST;
+          } else if (f.nullable === "contents") {
+            f2.nullable = NullableResult.CONTENTS;
+          } else if (f.nullable === "true") {
+            // shouldn't happen but ran into weirdness where it did...
+            f2.nullable = NullableResult.ITEM;
+          }
+        }
+
+        return f2;
+      },
+    );
+    ret.actionOnlyFields = actionOnlyFields;
+  }
+
+  if (action.canViewerDo !== undefined) {
+    if (typeof action.canViewerDo !== "object") {
+      delete ret.canViewerDo;
+      ret.canViewerDo = {};
+    }
+  }
+
+  return ret;
+}
+
+interface schemasDict {
+  [key: string]: ProcessedSchema;
+}
+
+interface ProcessedPattern {
+  name: string;
+  assocEdges: ProcessedAssocEdge[];
+  fields: ProcessedField[];
+  disableMixin?: boolean;
+}
+
+type ProcessedType = Omit<
+  Type,
+  "subFields" | "listElemType" | "unionFields"
+> & {
+  subFields?: ProcessedField[];
+  listElemType?: ProcessedType;
+  unionFields?: ProcessedField[];
+};
+
+export type ProcessedField = Omit<
+  Field,
+  | "defaultValueOnEdit"
+  | "defaultValueOnCreate"
+  | "privacyPolicy"
+  | "type"
+  | "serverDefault"
+> & {
+  name: string;
+  hasDefaultValueOnCreate?: boolean;
+  hasDefaultValueOnEdit?: boolean;
+  patternName?: string;
+  hasFieldPrivacy?: boolean;
+  hasEditFieldPrivacy?: boolean;
+  derivedFields?: ProcessedField[];
+  type: ProcessedType;
+  serverDefault?: string;
+};
+
+interface patternsDict {
+  [key: string]: ProcessedPattern;
+}
+
+interface Result {
+  schemas: schemasDict;
+  patterns: patternsDict;
+  globalSchema?: ProcessedGlobalSchema;
+  config?: {
+    rome?: RomeConfig;
+  };
+}
+
+declare type PotentialSchemas = {
+  [key: string]: any;
+};
+
+interface InputSchema extends Schema {
+  schemaPath?: string;
+}
+
+export async function parseSchema(
+  potentialSchemas: PotentialSchemas,
+  globalSchema?: GlobalSchema,
+): Promise<Result> {
+  let schemas: schemasDict = {};
+  let patterns: patternsDict = {};
+  let parsedGlobalSchema: ProcessedGlobalSchema | undefined;
+
+  if (globalSchema) {
+    parsedGlobalSchema = await parseGlobalSchema(globalSchema);
+    // set this so that we can use it, if we're trying to process server default or anything
+    // that ends up parsing,validating and formatting fields
+    setGlobalSchema(globalSchema);
+  }
+  for (const key in potentialSchemas) {
+    const value = potentialSchemas[key];
+    let schema: InputSchema;
+    const name = value.constructor.name;
+    // named class e.g. new BaseEntSchema
+    switch (name) {
+      case "Function":
+        schema = new value();
+        break;
+      default:
+        // implicit schema or named class
+        schema = value;
+    }
+    let processedSchema: ProcessedSchema = {
+      fields: [],
+      fieldOverrides: schema.fieldOverrides,
+      schemaPath: schema.schemaPath,
+      tableName: schema.tableName,
+      enumTable: schema.enumTable,
+      dbRows: schema.dbRows,
+      constraints: schema.constraints,
+      indices: schema.indices,
+      hideFromGraphQL: schema.hideFromGraphQL,
+      actions: schema.actions?.map((action) => processAction(action)) || [],
+      assocEdges: [],
+      assocEdgeGroups: [],
+      customGraphQLInterfaces: schema.customGraphQLInterfaces,
+      supportUpsert: schema.supportUpsert,
+      showCanViewerSee: schema.showCanViewerSee,
+      showCanViewerEdit: schema.showCanViewerEdit,
+    };
+    // let's put patterns first just so we have id, created_at, updated_at first
+    // ¯\_(ツ)_/¯
+    let patternNames: string[] = [];
+    if (schema.patterns) {
+      for (const pattern of schema.patterns) {
+        const ret = await processPattern(patterns, pattern, processedSchema);
+        patternNames.push(pattern.name);
+        if (ret.transformsSelect) {
+          if (processedSchema.transformsSelect) {
+            throw new Error(
+              `can only have one pattern which transforms default querying behavior`,
+            );
+          }
+          processedSchema.transformsSelect = true;
+          if (ret.transformsLoaderCodegen) {
+            processedSchema.transformsLoaderCodegen =
+              ret.transformsLoaderCodegen;
+          }
+        }
+
+        if (ret.transformsDelete) {
+          if (processedSchema.transformsDelete) {
+            throw new Error(
+              `can only have one pattern which transforms default deletion behavior`,
+            );
+          }
+          processedSchema.transformsDelete = true;
+        }
+      }
+    }
+    const fields = await processFields(schema.fields);
+    processedSchema.fields.push(...fields);
+    processedSchema.patternNames = patternNames;
+    if (schema.edges) {
+      const edges = processEdges(schema.edges);
+      processedSchema.assocEdges.push(...edges);
+    }
+    if (schema.edgeGroups) {
+      processEdgeGroups(processedSchema, schema.edgeGroups);
+    }
+
+    schemas[key] = processedSchema;
+  }
+  const rome = translatePrettier();
+
+  return {
+    schemas,
+    patterns,
+    globalSchema: parsedGlobalSchema,
+    config: {
+      rome,
+    },
+  };
+}
+
+interface RomeConfig {
+  indentStyle?: string;
+  lineWidth?: number;
+  indentSize?: number;
+  quoteStyle?: string;
+  quoteProperties?: string;
+  trailingComma?: string;
+}
+
+function translatePrettier(): RomeConfig | undefined {
+  const r = cosmiconfigSync("prettier").search();
+  if (!r) {
+    return;
+  }
+  const ret: RomeConfig = {};
+  if (r.config.printWidth !== undefined) {
+    ret.lineWidth = parseInt(r.config.printWidth);
+  }
+  if (r.config.useTabs) {
+    ret.indentStyle = "tab";
+  } else {
+    ret.indentStyle = "space";
+  }
+  if (r.config.tabWidth !== undefined) {
+    ret.indentSize = parseInt(r.config.tabWidth);
+  }
+  if (r.config.singleQuote) {
+    ret.quoteStyle = "single";
+  } else {
+    ret.quoteStyle = "double";
+  }
+  if (r.config.quoteProps !== undefined) {
+    if (r.config.quoteProps === "consistent") {
+      // rome doesn't support this
+      ret.quoteProperties = "as-needed";
+    } else {
+      ret.quoteProperties = r.config.quoteProps;
+    }
+  }
+  if (r.config.trailingComma !== undefined) {
+    ret.trailingComma = r.config.trailingComma;
+  }
+  return ret;
+}
+
+interface ProcessedGlobalSchema {
+  globalEdges: ProcessedAssocEdge[];
+  extraEdgeFields: ProcessedField[];
+  init?: boolean;
+  transformsEdges?: boolean;
+  globalFields?: ProcessedField[];
+}
+
+async function parseGlobalSchema(
+  s: GlobalSchema,
+): Promise<ProcessedGlobalSchema> {
+  const ret: ProcessedGlobalSchema = {
+    globalEdges: [],
+    extraEdgeFields: [],
+    init:
+      !!s.extraEdgeFields ||
+      s.transformEdgeRead !== undefined ||
+      s.transformEdgeWrite !== undefined ||
+      s.fields !== undefined,
+    transformsEdges: !!s.transformEdgeRead || !!s.transformEdgeWrite,
+  };
+
+  if (s.extraEdgeFields) {
+    ret.extraEdgeFields = await processFields(s.extraEdgeFields);
+  }
+
+  if (s.edges) {
+    ret.globalEdges = processEdges(s.edges);
+  }
+
+  if (s.fields) {
+    ret.globalFields = await processFields(s.fields);
+  }
+
+  return ret;
+}