graphile-build-pg
Version:
Build a GraphQL schema by reflection over a PostgreSQL schema. Easy to customize since it's built with plugins on graphile-build
250 lines (246 loc) • 9.39 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.newInflector = exports.defaultUtils = exports.defaultInflection = void 0;
var _graphileBuild = require("graphile-build");
var _PgBasicsPlugin = require("./plugins/PgBasicsPlugin");
/* THIS ENTIRE FILE IS DEPRECATED. DO NOT USE THIS. DO NOT EDIT THIS. */const outputMessages = [];
// eslint-disable-next-line flowtype/no-weak-types
function deprecate(fn, message) {
if (typeof fn !== "function") {
return fn;
}
return function (...args) {
if (outputMessages.indexOf(message) === -1) {
outputMessages.push(message);
// eslint-disable-next-line no-console
console.warn(new Error(message));
}
return fn.apply(this, args);
};
}
function deprecateEverything(obj) {
return Object.keys(obj).reduce((memo, key) => {
memo[key] = deprecate(obj[key], `Something (probably a plugin) called the old inflection system (inflector: '${key}'). This system has been deprecated since 4.0.0-beta.6 (4th May 2018) and is not used internally so using it may cause inconsistencies, instead please use the plugin-capable inflection system https://www.graphile.org/postgraphile/inflection/`);
return memo;
}, {});
}
const defaultUtils = {
constantCase: _graphileBuild.constantCase,
camelCase: _graphileBuild.camelCase,
upperCamelCase: _graphileBuild.upperCamelCase,
pluralize: _graphileBuild.pluralize,
singularize: _graphileBuild.singularize
};
exports.defaultUtils = defaultUtils;
const newInflector = (overrides = undefined, {
constantCase,
camelCase,
upperCamelCase,
pluralize,
singularize
} = defaultUtils) => {
function singularizeTable(tableName) {
return singularize(tableName).replace(/.(?:(?:[_-]i|I)nput|(?:[_-]p|P)atch)$/, "$&_record");
}
return deprecateEverything((0, _PgBasicsPlugin.preventEmptyResult)({
pluralize,
argument(name, index) {
return camelCase(name || `arg${index}`);
},
orderByType(typeName) {
return upperCamelCase(`${pluralize(typeName)}-order-by`);
},
orderByEnum(name, ascending, _table, _schema) {
return constantCase(`${name}_${ascending ? "asc" : "desc"}`);
},
domainType(name) {
return upperCamelCase(name);
},
enumName(inValue) {
let value = inValue;
if (value === "") {
return "_EMPTY_";
}
// Some enums use asterisks to signify wildcards - this might be for
// the whole item, or prefixes/suffixes, or even in the middle. This
// is provided on a best efforts basis, if it doesn't suit your
// purposes then please pass a custom inflector as mentioned below.
value = value.replace(/\*/g, "_ASTERISK_").replace(/^(_?)_+ASTERISK/, "$1ASTERISK").replace(/ASTERISK_(_?)_*$/, "ASTERISK$1");
// This is a best efforts replacement for common symbols that you
// might find in enums. Generally we only support enums that are
// alphanumeric, if these replacements don't work for you, you should
// pass a custom inflector that replaces this `enumName` method
// with one of your own chosing.
value = {
// SQL comparison operators
">": "GREATER_THAN",
">=": "GREATER_THAN_OR_EQUAL",
"=": "EQUAL",
"!=": "NOT_EQUAL",
"<>": "DIFFERENT",
"<=": "LESS_THAN_OR_EQUAL",
"<": "LESS_THAN",
// PostgreSQL LIKE shortcuts
"~~": "LIKE",
"~~*": "ILIKE",
"!~~": "NOT_LIKE",
"!~~*": "NOT_ILIKE",
// '~' doesn't necessarily represent regexps, but the three
// operators following it likely do, so we'll use the word TILDE
// in all for consistency.
"~": "TILDE",
"~*": "TILDE_ASTERISK",
"!~": "NOT_TILDE",
"!~*": "NOT_TILDE_ASTERISK",
// A number of other symbols where we're not sure of their
// meaning. We give them common generic names so that they're
// suitable for multiple purposes, e.g. favouring 'PLUS' over
// 'ADDITION' and 'DOT' over 'FULL_STOP'
"%": "PERCENT",
"+": "PLUS",
"-": "MINUS",
"/": "SLASH",
"\\": "BACKSLASH",
_: "UNDERSCORE",
"#": "POUND",
"£": "STERLING",
$: "DOLLAR",
"&": "AMPERSAND",
"@": "AT",
"'": "APOSTROPHE",
'"': "QUOTE",
"`": "BACKTICK",
":": "COLON",
";": "SEMICOLON",
"!": "EXCLAMATION_POINT",
"?": "QUESTION_MARK",
",": "COMMA",
".": "DOT",
"^": "CARET",
"|": "BAR",
"[": "OPEN_BRACKET",
"]": "CLOSE_BRACKET",
"(": "OPEN_PARENTHESIS",
")": "CLOSE_PARENTHESIS",
"{": "OPEN_BRACE",
"}": "CLOSE_BRACE"
}[value] || value;
return value;
},
enumType(name) {
return upperCamelCase(name);
},
conditionType(typeName) {
return upperCamelCase(`${typeName}-condition`);
},
inputType(typeName) {
return upperCamelCase(`${typeName}-input`);
},
rangeBoundType(typeName) {
return upperCamelCase(`${typeName}-range-bound`);
},
rangeType(typeName) {
return upperCamelCase(`${typeName}-range`);
},
patchType(typeName) {
return upperCamelCase(`${typeName}-patch`);
},
patchField(itemName) {
return camelCase(`${itemName}-patch`);
},
tableName(name, _schema) {
return camelCase(singularizeTable(name));
},
tableNode(name, _schema) {
return camelCase(singularizeTable(name));
},
allRows(name, schema) {
return camelCase(`all-${this.pluralize(this.tableName(name, schema))}`);
},
functionName(name, _schema) {
return camelCase(name);
},
functionPayloadType(name, _schema) {
return upperCamelCase(`${name}-payload`);
},
functionInputType(name, _schema) {
return upperCamelCase(`${name}-input`);
},
tableType(name, schema) {
return upperCamelCase(this.tableName(name, schema));
},
column(name, _table, _schema) {
return camelCase(name);
},
singleRelationByKeys(detailedKeys, table, schema) {
return camelCase(`${this.tableName(table, schema)}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}`);
},
rowByUniqueKeys(detailedKeys, table, schema) {
return camelCase(`${this.tableName(table, schema)}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}`);
},
updateByKeys(detailedKeys, table, schema) {
return camelCase(`update-${this.tableName(table, schema)}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}`);
},
deleteByKeys(detailedKeys, table, schema) {
return camelCase(`delete-${this.tableName(table, schema)}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}`);
},
updateNode(name, _schema) {
return camelCase(`update-${singularizeTable(name)}`);
},
deleteNode(name, _schema) {
return camelCase(`delete-${singularizeTable(name)}`);
},
updateByKeysInputType(detailedKeys, name, _schema) {
return upperCamelCase(`update-${singularizeTable(name)}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}-input`);
},
deleteByKeysInputType(detailedKeys, name, _schema) {
return upperCamelCase(`delete-${singularizeTable(name)}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}-input`);
},
updateNodeInputType(name, _schema) {
return upperCamelCase(`update-${singularizeTable(name)}-input`);
},
deleteNodeInputType(name, _schema) {
return upperCamelCase(`delete-${singularizeTable(name)}-input`);
},
manyRelationByKeys(detailedKeys, table, schema, _foreignTable, _foreignSchema) {
return camelCase(`${this.pluralize(this.tableName(table, schema))}-by-${detailedKeys.map(key => this.column(key.column, key.table, key.schema)).join("-and-")}`);
},
edge(typeName) {
return upperCamelCase(`${pluralize(typeName)}-edge`);
},
edgeField(name, _schema) {
return camelCase(`${singularizeTable(name)}-edge`);
},
connection(typeName) {
return upperCamelCase(`${this.pluralize(typeName)}-connection`);
},
scalarFunctionConnection(procName, _procSchema) {
return upperCamelCase(`${procName}-connection`);
},
scalarFunctionEdge(procName, _procSchema) {
return upperCamelCase(`${procName}-edge`);
},
createField(name, _schema) {
return camelCase(`create-${singularizeTable(name)}`);
},
createInputType(name, _schema) {
return upperCamelCase(`create-${singularizeTable(name)}-input`);
},
createPayloadType(name, _schema) {
return upperCamelCase(`create-${singularizeTable(name)}-payload`);
},
updatePayloadType(name, _schema) {
return upperCamelCase(`update-${singularizeTable(name)}-payload`);
},
deletePayloadType(name, _schema) {
return upperCamelCase(`delete-${singularizeTable(name)}-payload`);
},
...overrides
}));
};
exports.newInflector = newInflector;
const defaultInflection = newInflector();
exports.defaultInflection = defaultInflection;
//# sourceMappingURL=inflections.js.map