@simtlix/simfinity-js 2.6.4 → 3.2.0

package/src/mcp.js

@@ -0,0 +1,2 @@
+export * from '@simtlix/simfinity-mcp';
+export { default } from '@simtlix/simfinity-mcp';

package/src/mongo/adapter.js

@@ -0,0 +1,111 @@
+import mongoose from 'mongoose';
+import { getNamedType, isListType, isNonNullType } from 'graphql';
+
+import { createMongoModel } from './models.js';
+import { createMongoQueries } from './queries.js';
+import { withMongoTransaction } from './transactions.js';
+
+mongoose.set('strictQuery', false);
+
+const withSession = (query, session) => (session ? query.session(session) : query);
+
+export const createMongoAdapter = () => {
+  let queries;
+  const privateConnectionFields = new Map();
+
+  const addPrivateConnectionField = (typeName, fieldName) => {
+    if (!privateConnectionFields.has(typeName)) privateConnectionFields.set(typeName, new Set());
+    privateConnectionFields.get(typeName).add(fieldName);
+  };
+
+  const adapter = {
+    bind(binding) {
+      queries = createMongoQueries(binding);
+      adapter.buildQuery = queries.buildQuery;
+      adapter.buildFilterGroupMatch = queries.buildFilterGroupMatch;
+    },
+    prepare(registrations) {
+      for (const registration of registrations) {
+        for (const field of Object.values(registration.gqltype.getFields())) {
+          const relation = field.extensions?.relation;
+          const listType = isNonNullType(field.type) ? field.type.ofType : field.type;
+          if (!relation?.connectionField || relation.embedded || !isListType(listType)) continue;
+          const childType = getNamedType(field.type);
+          const childFields = childType.getFields();
+          const connectionExists = childFields[relation.connectionField]
+            || Object.entries(childFields).some(([fieldName, childField]) => {
+              const childRelation = childField.extensions?.relation;
+              return childRelation && !childRelation.embedded
+                && (childRelation.connectionField || fieldName) === relation.connectionField;
+            });
+          if (!connectionExists) addPrivateConnectionField(
+            childType.name,
+            relation.connectionField,
+          );
+        }
+      }
+    },
+    createModel(gqltype, onModelCreated, options) {
+      return createMongoModel(gqltype, (model) => {
+        for (const fieldName of privateConnectionFields.get(gqltype.name) || []) {
+          model.schema.add({ [fieldName]: mongoose.Schema.Types.ObjectId });
+          model.schema.index({ [fieldName]: 1 });
+        }
+        if (onModelCreated) onModelCreated(model);
+      }, options);
+    },
+    castId(value) {
+      return new mongoose.Types.ObjectId(value);
+    },
+    withTransaction: withMongoTransaction,
+    newRecord(Model, data, session) {
+      const record = new Model(data);
+      record.$session(session);
+      return record;
+    },
+    saveRecord(Model, record) {
+      return record.save();
+    },
+    toObject(record) {
+      return typeof record?.toObject === 'function' ? record.toObject() : record;
+    },
+    getById(Model, id, session, { projection, plain, requiredId } = {}) {
+      let query = withSession(requiredId == null ? Model.findById(id, projection)
+        : Model.findOne({ $and: [{ _id: requiredId }, { _id: id }] }, projection), session);
+      if (plain) query = query.lean();
+      return query;
+    },
+    prepareUpdate(set, unset) {
+      return Object.keys(unset).length > 0 ? { ...set, $unset: unset } : set;
+    },
+    update(Model, id, update, session) {
+      return withSession(Model.findByIdAndUpdate(id, update, { new: true }), session);
+    },
+    delete(Model, id, session) {
+      return withSession(Model.findByIdAndDelete(id), session);
+    },
+    async find(Model, gqltype, args, session, { requiredId } = {}) {
+      const pipeline = await queries.buildQuery(args, gqltype);
+      if (requiredId != null) pipeline.unshift({ $match: { _id: Model.schema.path('_id').cast(requiredId) } });
+      if (pipeline.length === 0) return withSession(Model.find({}), session);
+      return withSession(Model.aggregate(pipeline), session);
+    },
+    async count(Model, gqltype, args, session) {
+      const pipeline = await queries.buildQuery(args, gqltype, true);
+      const result = await withSession(Model.aggregate(pipeline), session);
+      return result[0] ? result[0].size : 0;
+    },
+    async aggregate(Model, gqltype, args, session) {
+      const pipeline = await queries.buildAggregationQuery(args, gqltype, args.aggregation);
+      return withSession(Model.aggregate(pipeline), session);
+    },
+    async findChildren(Model, gqltype, connectionField, parentId, args, session) {
+      const pipeline = await queries.buildQuery(args, gqltype);
+      const path = Model.schema.path(connectionField);
+      pipeline.unshift({ $match: { [connectionField]: path ? path.cast(parentId) : parentId } });
+      return withSession(Model.aggregate(pipeline), session);
+    },
+  };
+
+  return adapter;
+};

package/src/mongo/models.js

@@ -0,0 +1,160 @@
+import {
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLString,
+} from 'graphql';
+import mongoose from 'mongoose';
+
+const isNonNullOfType = (fieldEntryType, graphQLType) => (
+  fieldEntryType instanceof GraphQLNonNull && fieldEntryType.ofType instanceof graphQLType
+);
+
+const unwrapNonNull = (type) => (type instanceof GraphQLNonNull ? type.ofType : type);
+
+const getListItemType = (type) => {
+  const listType = unwrapNonNull(type);
+  if (!(listType instanceof GraphQLList)) return null;
+  return unwrapNonNull(listType.ofType);
+};
+
+const isCustomValidatedScalar = (type) => (
+  type instanceof GraphQLScalarType && type.baseScalarType
+);
+
+const matchesScalar = (fieldType, target) => {
+  if (fieldType === target) return true;
+  if (fieldType instanceof GraphQLNonNull && fieldType.ofType === target) return true;
+  if (isCustomValidatedScalar(fieldType) && fieldType.baseScalarType === target) return true;
+  return fieldType instanceof GraphQLNonNull
+    && isCustomValidatedScalar(fieldType.ofType)
+    && fieldType.ofType.baseScalarType === target;
+};
+
+const getEffectiveTypeName = (type) => (
+  type instanceof GraphQLScalarType && type.baseScalarType ? type.baseScalarType.name : type.name
+);
+
+const isGraphQLisoDate = (typeName) => (
+  typeName === 'DateTime' || typeName === 'Date' || typeName === 'Time'
+);
+
+const listItemMatchesScalar = (listType, target) => {
+  const ofType = getListItemType(listType);
+  return ofType === target
+    || (isCustomValidatedScalar(ofType) && ofType.baseScalarType === target);
+};
+
+const withUnique = (fieldEntry, mongoType) => (fieldEntry.extensions && fieldEntry.extensions.unique
+  ? { type: mongoType, unique: true }
+  : mongoType);
+
+const generateSchemaDefinition = (gqlType) => {
+  const argTypes = gqlType.getFields();
+  const schemaArg = {};
+
+  for (const [fieldEntryName, fieldEntry] of Object.entries(argTypes)) {
+    const { type } = fieldEntry;
+
+    if (matchesScalar(type, GraphQLID)) {
+      schemaArg[fieldEntryName] = mongoose.Schema.Types.ObjectId;
+    } else if (matchesScalar(type, GraphQLString)
+      || type instanceof GraphQLEnumType
+      || isNonNullOfType(type, GraphQLEnumType)) {
+      schemaArg[fieldEntryName] = withUnique(fieldEntry, String);
+    } else if (matchesScalar(type, GraphQLInt) || matchesScalar(type, GraphQLFloat)) {
+      schemaArg[fieldEntryName] = withUnique(fieldEntry, Number);
+    } else if (matchesScalar(type, GraphQLBoolean)) {
+      schemaArg[fieldEntryName] = Boolean;
+    } else if (type instanceof GraphQLObjectType || isNonNullOfType(type, GraphQLObjectType)) {
+      if (fieldEntry.extensions && fieldEntry.extensions.relation) {
+        if (!fieldEntry.extensions.relation.embedded) {
+          const key = fieldEntry.extensions.relation.connectionField || fieldEntry.name;
+          schemaArg[key] = mongoose.Schema.Types.ObjectId;
+        } else {
+          const entryType = unwrapNonNull(type);
+          if (entryType === gqlType) {
+            throw new Error('A type cannot have a field of its same type and embedded');
+          }
+          schemaArg[fieldEntryName] = generateSchemaDefinition(entryType);
+        }
+      }
+    } else if (getListItemType(type)) {
+      const itemType = getListItemType(type);
+      if (fieldEntry.extensions && fieldEntry.extensions.relation) {
+        if (fieldEntry.extensions.relation.embedded) {
+          if (itemType === gqlType) {
+            throw new Error('A type cannot have a field of its same type and embedded');
+          }
+          schemaArg[fieldEntryName] = [generateSchemaDefinition(itemType)];
+        }
+      } else if (listItemMatchesScalar(type, GraphQLID)) {
+        schemaArg[fieldEntryName] = [mongoose.Schema.Types.ObjectId];
+      } else if (listItemMatchesScalar(type, GraphQLString) || itemType instanceof GraphQLEnumType) {
+        schemaArg[fieldEntryName] = [String];
+      } else if (listItemMatchesScalar(type, GraphQLBoolean)) {
+        schemaArg[fieldEntryName] = [Boolean];
+      } else if (listItemMatchesScalar(type, GraphQLInt) || listItemMatchesScalar(type, GraphQLFloat)) {
+        schemaArg[fieldEntryName] = [Number];
+      } else if (isGraphQLisoDate(getEffectiveTypeName(itemType))) {
+        schemaArg[fieldEntryName] = [Date];
+      }
+    } else if (isGraphQLisoDate(getEffectiveTypeName(unwrapNonNull(type)))) {
+      schemaArg[fieldEntryName] = Date;
+    }
+  }
+
+  return schemaArg;
+};
+
+const findObjectIdFields = (schemaDefinition, parentPath = '') => {
+  const objectIdFields = [];
+
+  for (const [fieldName, fieldDefinition] of Object.entries(schemaDefinition)) {
+    const currentPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
+
+    if (fieldDefinition === mongoose.Schema.Types.ObjectId) {
+      objectIdFields.push(currentPath);
+    } else if (typeof fieldDefinition === 'object' && fieldDefinition !== null) {
+      if (Array.isArray(fieldDefinition)) {
+        const arrayElement = fieldDefinition[0];
+        if (typeof arrayElement === 'object' && arrayElement !== null) {
+          objectIdFields.push(...findObjectIdFields(arrayElement, currentPath));
+        }
+      } else if (fieldDefinition.type === mongoose.Schema.Types.ObjectId) {
+        objectIdFields.push(currentPath);
+      } else if (!fieldDefinition.type) {
+        objectIdFields.push(...findObjectIdFields(fieldDefinition, currentPath));
+      }
+    }
+  }
+
+  return objectIdFields;
+};
+
+const createSchemaWithIndexes = (schemaDefinition) => {
+  const schema = new mongoose.Schema(schemaDefinition);
+  findObjectIdFields(schemaDefinition).forEach((fieldPath) => {
+    schema.index({ [fieldPath]: 1 });
+  });
+  return schema;
+};
+
+export const createMongoModel = (gqlType, onModelCreated, { createCollection = true } = {}) => {
+  const schemaDefinition = generateSchemaDefinition(gqlType);
+  const schema = createSchemaWithIndexes(schemaDefinition);
+  const model = mongoose.model(gqlType.name, schema, gqlType.name);
+  if (onModelCreated) {
+    onModelCreated(model);
+  }
+  if (createCollection) {
+    model.createCollection();
+  }
+  return model;
+};