@smartive/graphql-magic 1.0.1

package/src/generate/index.ts

@@ -0,0 +1,5 @@
+// created from 'create-ts-index'
+
+export * from './generate';
+export * from './mutations';
+export * from './utils';

package/src/generate/mutations.ts

@@ -0,0 +1,35 @@
+import upperCase from 'lodash/upperCase';
+import { Models } from '../models';
+
+const constantCase = (str: string) => upperCase(str).replace(/ /g, '_');
+
+export const generateMutations = (models: Models) => {
+  const parts: string[] = [];
+  for (const { name, creatable, updatable, deletable } of models) {
+    if (creatable) {
+      parts.push(
+        `export const CREATE_${constantCase(
+          name
+        )} = gql\`\n  mutation Create${name}Mutation($data: Create${name}!) {\n    create${name}(data: $data) { id }\n  }\n\`;`
+      );
+    }
+
+    if (updatable) {
+      parts.push(
+        `export const UPDATE_${constantCase(
+          name
+        )} = gql\`\n  mutation Update${name}Mutation($id: ID!, $data: Update${name}!) {\n    update${name}(where: { id: $id }, data: $data) { id }\n  }\n\`;`
+      );
+    }
+
+    if (deletable) {
+      parts.push(
+        `export const DELETE_${constantCase(
+          name
+        )} = gql\`\n  mutation Delete${name}Mutation($id: ID!) {\n    delete${name}(where: { id: $id })\n  }\n\`;`
+      );
+    }
+  }
+
+  return `import { gql } from "@smartive-private/graphql-magic";\n\n${parts.join('\n\n')}`;
+};

package/src/generate/utils.ts

@@ -0,0 +1,223 @@
+import {
+  ArgumentNode,
+  DefinitionNode,
+  DirectiveDefinitionNode,
+  DirectiveNode,
+  DocumentNode,
+  EnumTypeDefinitionNode,
+  EnumValueDefinitionNode,
+  FieldDefinitionNode,
+  InputObjectTypeDefinitionNode,
+  InputValueDefinitionNode,
+  InterfaceTypeDefinitionNode,
+  ListTypeNode,
+  NamedTypeNode,
+  NameNode,
+  NonNullTypeNode,
+  ObjectFieldNode,
+  ObjectTypeDefinitionNode,
+  ScalarTypeDefinitionNode,
+  StringValueNode,
+  TypeNode,
+  ValueNode,
+} from 'graphql';
+import { DateTime } from 'luxon';
+import { Field } from '../models';
+import { Directive, Enum, Value, Values } from '../values';
+
+export type DirectiveLocation =
+  | 'ARGUMENT_DEFINITION'
+  | 'INPUT_FIELD_DEFINITION'
+  | 'FIELD'
+  | 'FIELD_DEFINITION'
+  | 'OBJECT'
+  | 'INTERFACE'
+  | 'INPUT_OBJECT';
+
+export const document = (definitions: DefinitionNode[]): DocumentNode => ({
+  kind: 'Document',
+  definitions,
+});
+
+export const directive = (nme: string, locations: DirectiveLocation[], fields?: Field[]): DirectiveDefinitionNode => ({
+  name: name(nme),
+  repeatable: false,
+  kind: 'DirectiveDefinition',
+  arguments: fields && inputValues(fields),
+  locations: locations.map(name),
+});
+
+export const scalar = (nme: string): ScalarTypeDefinitionNode => ({
+  name: name(nme),
+  kind: 'ScalarTypeDefinition',
+});
+
+export const input = (nme: string, fields: Field[], dvs?: Directive[]): InputObjectTypeDefinitionNode => ({
+  name: name(nme),
+  fields: inputValues(fields),
+  kind: 'InputObjectTypeDefinition',
+  directives: directives(dvs),
+});
+
+export const object = (nme: string, fds: Field[], interfaces?: string[], dvs?: Directive[]): ObjectTypeDefinitionNode => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: 'ObjectTypeDefinition',
+  interfaces: interfaces && interfaces.map((i) => namedType(i)),
+  directives: directives(dvs),
+});
+
+export const iface = (nme: string, fds: Field[], dvs?: Directive[]): InterfaceTypeDefinitionNode => ({
+  name: name(nme),
+  fields: fields(fds),
+  kind: 'InterfaceTypeDefinition',
+  directives: directives(dvs),
+});
+
+export const inputValues = (fields: Field[]): InputValueDefinitionNode[] =>
+  fields.map(
+    (field): InputValueDefinitionNode => ({
+      kind: 'InputValueDefinition',
+      name: name(field.name),
+      type: fieldType(field),
+      defaultValue: field.default === undefined ? undefined : value(field.default),
+      directives: directives(field.directives),
+    })
+  );
+
+export const fields = (fields: Field[]): FieldDefinitionNode[] =>
+  fields.map(
+    (field): FieldDefinitionNode => ({
+      kind: 'FieldDefinition',
+      name: name(field.name),
+      type: fieldType(field),
+      arguments: field.args?.map((arg) => ({
+        kind: 'InputValueDefinition',
+        name: name(arg.name),
+        type: fieldType(arg),
+        defaultValue: arg.default === undefined ? undefined : value(arg.default),
+      })),
+      directives: directives(field.directives),
+    })
+  );
+
+export const inputValue = (
+  nme: string,
+  type: TypeNode,
+  dvs?: Directive[],
+  description?: string,
+  defaultValue?: Value
+): InputValueDefinitionNode => ({
+  name: name(nme),
+  type,
+  kind: 'InputValueDefinition',
+  directives: directives(dvs),
+  defaultValue: defaultValue ? value(defaultValue) : undefined,
+  description: description ? (value(description) as StringValueNode) : undefined,
+});
+
+export const directives = (directives?: Directive[]): DirectiveNode[] | undefined =>
+  directives?.map(
+    (directive): DirectiveNode => ({
+      kind: 'Directive',
+      name: name(directive.name),
+      arguments: args(directive.values),
+    })
+  );
+
+export const args = (ags: Values | undefined): ReadonlyArray<ArgumentNode> | undefined =>
+  ags?.map(
+    (argument): ArgumentNode => ({
+      kind: 'Argument',
+      name: name(argument.name),
+      value: value(argument.values),
+    })
+  );
+
+export const enm = (nme: string, values: string[]): EnumTypeDefinitionNode => ({
+  name: name(nme),
+  kind: 'EnumTypeDefinition',
+  values: values.map(
+    (v): EnumValueDefinitionNode => ({
+      kind: 'EnumValueDefinition',
+      name: name(v),
+    })
+  ),
+});
+
+export const nonNull = (type: NamedTypeNode | ListTypeNode): NonNullTypeNode => ({
+  type,
+  kind: 'NonNullType',
+});
+
+export const namedType = (nme: string): NamedTypeNode => ({
+  kind: 'NamedType',
+  name: name(nme),
+});
+
+export const list = (type: TypeNode): ListTypeNode => ({
+  type,
+  kind: 'ListType',
+});
+
+export const name = (name: string): NameNode => ({
+  kind: 'Name',
+  value: name,
+});
+
+export const fieldType = (field: Field) => {
+  let type: TypeNode = namedType(field.type);
+  if (field.list) {
+    type = list(nonNull(type));
+  }
+  if (field.nonNull) {
+    type = nonNull(type);
+  }
+  return type;
+};
+
+export const value = (val: Value = null): ValueNode =>
+  val === null
+    ? {
+        kind: 'NullValue',
+      }
+    : typeof val === 'boolean'
+    ? {
+        kind: 'BooleanValue',
+        value: val,
+      }
+    : typeof val === 'number'
+    ? {
+        kind: 'IntValue',
+        value: `${val}`,
+      }
+    : typeof val === 'string'
+    ? {
+        kind: 'StringValue',
+        value: val,
+      }
+    : val instanceof Enum
+    ? {
+        kind: 'EnumValue',
+        value: val.value,
+      }
+    : Array.isArray(val)
+    ? {
+        kind: 'ListValue',
+        values: val.map(value),
+      }
+    : val instanceof DateTime
+    ? {
+        kind: 'StringValue',
+        value: val.toString(),
+      }
+    : {
+        kind: 'ObjectValue',
+        fields: Object.keys(val).map(
+          (nme): ObjectFieldNode => ({
+            kind: 'ObjectField',
+            name: name(nme),
+            value: value(val[nme]),
+          })
+        ),
+      };

package/src/index.ts

@@ -0,0 +1,12 @@
+// created from 'create-ts-index'
+
+export * from './client';
+export * from './generate';
+export * from './migrations';
+export * from './permissions';
+export * from './resolvers';
+export * from './context';
+export * from './errors';
+export * from './models';
+export * from './utils';
+export * from './values';