@baeta/plugin-prisma 0.0.2 → 0.0.14

package/lib/schema-builder/schema-builder.ts

@@ -1,186 +0,0 @@
-import { buildSchema, validateSchema } from 'graphql';
-import { concat, mergeDeepWith } from 'ramda';
-import { Store } from '../context';
-import { DMMF } from '../dmmf';
-import { GenerateOptions } from '../generator';
-import { findModelByEnum } from '../model-enum';
-import { findModelByInput } from '../model-inputs';
-import { findModelByOperationSchema } from '../model-operations';
-import { findModelByOutput } from '../model-outputs';
-import { directives, printDirectives } from '../print/directive';
-import { printPrismaEnum } from '../print/prisma-enum';
-import { printPrismaEnumModel } from '../print/prisma-enum-model';
-import { printPrismaInput } from '../print/prisma-input';
-import { printPrismaModel } from '../print/prisma-model';
-import { printPrismaOperation, printPrismaOutput } from '../print/prisma-output';
-import { printScalars, scalars } from '../print/type';
-import { createVisitorBuilder } from '../visitor';
-import { createGlobalSchemas, createModuleSchemas } from './schema-builder-files';
-import { isOperation } from './schema-builder-utils';
-
-export interface GlobalSchemaDefinition {
-  enums: string[];
-  scalars: string[];
-  directives: string[];
-  inputTypes: string[];
-  outputTypes: string[];
-}
-
-export interface ModuleSchemaDefinition {
-  name: string;
-  model: string[];
-  enums: string[];
-  queries: string[];
-  mutations: string[];
-  inputTypes: string[];
-  outputTypes: string[];
-}
-
-export type ModuleDefinitionMap = Record<string, ModuleSchemaDefinition | undefined>;
-
-export function createSchemaBuilder(store: Store, options: GenerateOptions) {
-  const { models, inputsMap, outputsMap, operationsMap } = store;
-
-  const moduleDefinitions: ModuleDefinitionMap = {};
-
-  let globalDefinitions: GlobalSchemaDefinition = {
-    enums: [],
-    scalars: scalars,
-    directives: directives,
-    inputTypes: [],
-    outputTypes: [],
-  };
-
-  const schema = [printScalars(), printDirectives()];
-
-  function pushDefinition(model: string, def: Partial<ModuleSchemaDefinition>) {
-    const current = moduleDefinitions[model] ?? {
-      name: model,
-      model: [],
-      queries: [],
-      mutations: [],
-      inputTypes: [],
-      outputTypes: [],
-      enums: [],
-    };
-    moduleDefinitions[model] = mergeDeepWith(concat, current, def);
-  }
-
-  function addToGlobal(def: Partial<GlobalSchemaDefinition>) {
-    globalDefinitions = mergeDeepWith(concat, globalDefinitions, def);
-  }
-
-  function addToSchema(value: string) {
-    schema.push(value);
-  }
-
-  const visitor = createVisitorBuilder();
-
-  visitor.onModel((model) => {
-    const content = printPrismaModel(model);
-    addToSchema(content);
-    pushDefinition(model.name, { model: [content] });
-  });
-
-  visitor.onModelEnum((enumModel) => {
-    const content = printPrismaEnumModel(enumModel);
-    addToSchema(content);
-    addToGlobal({ enums: [content] });
-  });
-
-  visitor.onSchemaEnum((enumType) => {
-    const content = printPrismaEnum(enumType);
-    const model = findModelByEnum(models, enumType);
-
-    addToSchema(content);
-
-    if (!model) {
-      return addToGlobal({ enums: [content] });
-    }
-
-    pushDefinition(model, { enums: [content] });
-  });
-
-  visitor.onInputType((inputType) => {
-    const content = printPrismaInput(inputType);
-    const model = findModelByInput(inputsMap, inputType);
-
-    addToSchema(content);
-
-    if (!model) {
-      return addToGlobal({ inputTypes: [content] });
-    }
-
-    pushDefinition(model, { inputTypes: [content] });
-  });
-
-  visitor.onOutputType((outputType) => {
-    const content = printPrismaOutput(outputType);
-
-    addToSchema(content);
-
-    if (isOperation(outputType.name)) {
-      return handleOperation(outputType, outputType.name);
-    }
-
-    const model = findModelByOutput(outputsMap, outputType);
-
-    if (!model) {
-      return addToGlobal({ outputTypes: [content] });
-    }
-
-    pushDefinition(model, { outputTypes: [content] });
-  });
-
-  function handleOperation(outputType: DMMF.OutputType, operation: 'Query' | 'Mutation') {
-    for (const field of outputType.fields) {
-      const model = findModelByOperationSchema(operationsMap, field);
-
-      if (!model) {
-        continue;
-      }
-
-      const content = printPrismaOperation(operationsMap, field);
-
-      if (!content) {
-        continue;
-      }
-
-      if (operation === 'Query') {
-        pushDefinition(model, {
-          queries: [content],
-        });
-      }
-
-      if (operation === 'Mutation') {
-        pushDefinition(model, {
-          mutations: [content],
-        });
-      }
-    }
-  }
-
-  function validate() {
-    validateSchema(buildSchema(schema.join('\n')));
-  }
-
-  function compose() {
-    validate();
-
-    const fileOptions = {
-      root: options.modulesDir,
-      namespace: options.schemaNamespace,
-      casing: options.casing,
-    };
-
-    return [
-      ...createGlobalSchemas(globalDefinitions, fileOptions),
-      ...createModuleSchemas(moduleDefinitions, fileOptions),
-    ];
-  }
-
-  return {
-    visitor,
-    compose,
-  };
-}

package/lib/visitor.ts

@@ -1,119 +0,0 @@
-import { DMMF } from '@prisma/generator-helper';
-
-type VisitorInput<T> = (model: T) => void | Promise<void>;
-
-export interface Visitor {
-  model: Array<VisitorInput<DMMF.Model>>;
-  modelEnum: Array<VisitorInput<DMMF.DatamodelEnum>>;
-  schemaEnum: Array<VisitorInput<DMMF.SchemaEnum>>;
-  inputType: Array<VisitorInput<DMMF.InputType>>;
-  outputType: Array<VisitorInput<DMMF.OutputType>>;
-}
-
-export type VisitorBuilder = ReturnType<typeof createVisitorBuilder>;
-
-export function createVisitorBuilder() {
-  const visitor: Visitor = {
-    model: [],
-    modelEnum: [],
-    schemaEnum: [],
-    inputType: [],
-    outputType: [],
-  };
-
-  function getVisitor() {
-    return visitor;
-  }
-
-  function onModel(input: VisitorInput<DMMF.Model>) {
-    visitor.model.push(input);
-  }
-
-  function onModelEnum(input: VisitorInput<DMMF.DatamodelEnum>) {
-    visitor.modelEnum.push(input);
-  }
-
-  function onSchemaEnum(input: VisitorInput<DMMF.SchemaEnum>) {
-    visitor.schemaEnum.push(input);
-  }
-
-  function onInputType(input: VisitorInput<DMMF.InputType>) {
-    visitor.inputType.push(input);
-  }
-
-  function onOutputType(input: VisitorInput<DMMF.OutputType>) {
-    visitor.outputType.push(input);
-  }
-
-  return {
-    getVisitor,
-    onModel,
-    onModelEnum,
-    onSchemaEnum,
-    onInputType,
-    onOutputType,
-  };
-}
-
-function visitItem<T>(
-  item: T,
-  visitor: Visitor,
-  getInputs: (visitor: Visitor) => Array<VisitorInput<T>>
-) {
-  const handlers = getInputs(visitor);
-  return handlers.map((handler) => handler(item));
-}
-
-export function visitItems<T>(
-  items: T[],
-  visitors: Visitor[],
-  getInputs: (visitor: Visitor) => Array<VisitorInput<T>>
-) {
-  const promises: Array<void | Promise<void>> = [];
-
-  for (const item of items) {
-    for (const visitor of visitors) {
-      promises.push(...visitItem(item, visitor, getInputs));
-    }
-  }
-
-  return Promise.all(promises);
-}
-
-export function visit(document: DMMF.Document, visitors: Visitor[]) {
-  const models = visitItems(
-    document.datamodel.models,
-    visitors,
-    (visitor) => visitor.model
-  );
-
-  const modelEnums = visitItems(
-    document.datamodel.enums,
-    visitors,
-    (visitor) => visitor.modelEnum
-  );
-
-  const inputTypes = visitItems(
-    document.schema.inputObjectTypes.prisma,
-    visitors,
-    (visitor) => visitor.inputType
-  );
-
-  const outputTypes = visitItems(
-    document.schema.outputObjectTypes.prisma,
-    visitors,
-    (visitor) => visitor.outputType
-  );
-
-  const enumTypes = visitItems(
-    document.schema.enumTypes.prisma,
-    visitors,
-    (visitor) => visitor.schemaEnum
-  );
-
-  return Promise.all([models, modelEnums, inputTypes, outputTypes, enumTypes]).then(
-    () => {
-      // do nothing
-    }
-  );
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../config/tsconfig.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "outDir": "dist"
-  },
-  "include": ["**/*.ts"],
-  "exclude": ["dist"]
-}

package/utils/casing.ts

@@ -1,23 +0,0 @@
-import { camelCase, paramCase, pascalCase, snakeCase } from 'change-case-all';
-
-export type Casing = 'camelCase' | 'PascalCase' | 'snake_case' | 'kebab-case';
-
-export function changeCase(input: string, casing: Casing) {
-  if (casing === 'camelCase') {
-    return camelCase(input);
-  }
-
-  if (casing === 'PascalCase') {
-    return pascalCase(input);
-  }
-
-  if (casing === 'snake_case') {
-    return snakeCase(input);
-  }
-
-  if (casing === 'kebab-case') {
-    return paramCase(input);
-  }
-
-  return input;
-}

package/utils/string.ts

@@ -1,9 +0,0 @@
-export function filterEmpty<T>(items: Array<T | undefined | null>): T[] {
-  return items.filter((item) => item != null && item != '') as T[];
-}
-
-export function indent(number = 2) {
-  return (text: string) => {
-    return ' '.repeat(number) + text;
-  };
-}