graphile-build-pg/node8plus/plugins/PgOrderComputedColumnsPlugin.js

Build a GraphQL schema by reflection over a PostgreSQL schema. Easy to customize since it's built with plugins on graphile-build

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _PgComputedColumnsPlugin = require("./PgComputedColumnsPlugin");
var PgOrderComputedColumnsPlugin = function PgOrderComputedColumnsPlugin(builder) {
  builder.hook("GraphQLEnumType:values", (values, build, context) => {
    const {
      extend,
      inflection,
      pgOmit: omit,
      describePgEntity,
      pgIntrospectionResultsByKind: introspectionResultsByKind,
      pgSql: sql
    } = build;
    const {
      scope: {
        isPgRowSortEnum,
        pgIntrospection: table
      }
    } = context;
    if (!isPgRowSortEnum || !table || table.kind !== "class") {
      return values;
    }
    const compatibleComputedColumns = introspectionResultsByKind.procedure.reduce((memo, proc) => {
      /* ALSO SEE PgConditionComputedColumnPlugin */
      // Must be marked @sortable
      if (!proc.tags.sortable) return memo;

      // Must not be omitted
      if (omit(proc, "execute")) return memo;

      // Must be a computed column
      const computedColumnDetails = (0, _PgComputedColumnsPlugin.getComputedColumnDetails)(build, table, proc);
      if (!computedColumnDetails) return memo;
      const {
        pseudoColumnName
      } = computedColumnDetails;

      // Must have only one required argument
      const nonOptionalArgumentsCount = proc.inputArgsCount - proc.argDefaultsNum;
      if (nonOptionalArgumentsCount > 1) {
        return memo;
      }

      // Must return a scalar
      if (proc.returnsSet) return memo;
      const returnType = introspectionResultsByKind.typeById[proc.returnTypeId];
      if (returnType.isPgArray) return memo;
      const returnTypeTable = introspectionResultsByKind.classById[returnType.classId];
      if (returnTypeTable) return memo;
      const isRecordLike = returnType.id === "2249";
      if (isRecordLike) return memo;
      const isVoid = String(returnType.id) === "2278";
      if (isVoid) return memo;

      // Looks good
      memo.push({
        proc,
        pseudoColumnName
      });
      return memo;
    }, []);
    return extend(values, compatibleComputedColumns.reduce((memo, {
      proc,
      pseudoColumnName
    }) => {
      const ascFieldName = inflection.orderByComputedColumnEnum(pseudoColumnName, proc, table, true);
      const descFieldName = inflection.orderByComputedColumnEnum(pseudoColumnName, proc, table, false);
      const unique = !!proc.tags.isUnique;
      const functionCall = ({
        queryBuilder
      }) => sql.fragment`(${sql.identifier(proc.namespaceName, proc.name)}(${queryBuilder.getTableAlias()}))`;
      memo = extend(memo, {
        [ascFieldName]: {
          value: {
            alias: ascFieldName.toLowerCase(),
            specs: [[functionCall, true]],
            unique
          }
        }
      }, `Adding ascending orderBy enum value for ${describePgEntity(proc)}. You can rename this field by removing the '@sortable' smart comment from the function.`);
      memo = extend(memo, {
        [descFieldName]: {
          value: {
            alias: descFieldName.toLowerCase(),
            specs: [[functionCall, false]],
            unique
          }
        }
      }, `Adding descending orderBy enum value for ${describePgEntity(proc)}. You can rename this field by removing the '@sortable' smart comment from the function.`);
      return memo;
    }, {}), `Adding order values from table '${table.name}'`);
  }, ["PgOrderComputedColumns"]);
};
exports.default = PgOrderComputedColumnsPlugin;
//# sourceMappingURL=PgOrderComputedColumnsPlugin.js.map