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

package/src/index.ts

@@ -1,145 +0,0 @@
-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

@@ -1,585 +0,0 @@
-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;
-}