@simtlix/simfinity-js 2.6.4 → 3.2.0

package/src/plugins.js

@@ -1,53 +1,2 @@
-import { createAuthPlugin } from './auth/index.js';
-
-export { createAuthPlugin } from './auth/index.js';
-
-/**
- * Apollo Server plugin to add count to GraphQL response extensions
- * @returns {Object} Apollo Server plugin
- */
-export const apolloCountPlugin = () => {
-  return {
-    async requestDidStart() {
-      return {
-        async willSendResponse({ contextValue, response }) {
-          if (response.body.kind === 'single' && contextValue?.count) {
-            response.body.singleResult.extensions = {
-              ...(response.body.singleResult.extensions || {}),
-              count: contextValue.count,
-            };
-          }
-        },
-      };
-    },
-  };
-};
-
-/**
- * Envelop plugin to add count to GraphQL response extensions
- * @returns {Object} Envelop plugin
- */
-export const envelopCountPlugin = () => {
-  return {
-    onExecute() {
-      return {
-        onExecuteDone({ result, args }) {
-          if (args.contextValue?.count) {
-            result.extensions = {
-              ...result.extensions,
-              count: args.contextValue.count,
-            };
-          }
-        },
-      };
-    },
-  };
-};
-
-const plugins = {
-  createAuthPlugin,
-  apolloCountPlugin,
-  envelopCountPlugin,
-};
-
-export default plugins;
+export * from '@simtlix/simfinity-core/plugins';
+export { default } from '@simtlix/simfinity-core/plugins';

package/src/scalars.js

@@ -1,188 +1,2 @@
-import {
-  GraphQLString, GraphQLInt, GraphQLFloat,
-} from 'graphql';
-import { createValidatedScalar } from './index.js';
-
-/**
- * Email scalar - validates email format
- * Type name: Email_String
- */
-export const EmailScalar = createValidatedScalar(
-  'Email',
-  'A valid email address',
-  GraphQLString,
-  (value) => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(value)) {
-      throw new Error('Invalid email format');
-    }
-  },
-);
-
-/**
- * URL scalar - validates URL format
- * Type name: URL_String
- */
-export const URLScalar = createValidatedScalar(
-  'URL',
-  'A valid URL',
-  GraphQLString,
-  (value) => {
-    try {
-      new URL(value);
-    } catch {
-      throw new Error('Invalid URL format');
-    }
-  },
-);
-
-/**
- * PositiveInt scalar - validates positive integers
- * Type name: PositiveInt_Int
- */
-export const PositiveIntScalar = createValidatedScalar(
-  'PositiveInt',
-  'A positive integer',
-  GraphQLInt,
-  (value) => {
-    if (value <= 0) {
-      throw new Error('Value must be positive');
-    }
-  },
-);
-
-/**
- * PositiveFloat scalar - validates positive floats
- * Type name: PositiveFloat_Float
- */
-export const PositiveFloatScalar = createValidatedScalar(
-  'PositiveFloat',
-  'A positive float',
-  GraphQLFloat,
-  (value) => {
-    if (value <= 0) {
-      throw new Error('Value must be positive');
-    }
-  },
-);
-
-/**
- * Factory function to create a bounded string scalar
- * @param {string} name - Name for the scalar
- * @param {number} min - Minimum length
- * @param {number} max - Maximum length
- * @returns {GraphQLScalarType} A scalar type with length validation
- */
-export const createBoundedStringScalar = (name, min, max) => {
-  return createValidatedScalar(
-    name,
-    `A string with length between ${min} and ${max} characters`,
-    GraphQLString,
-    (value) => {
-      if (typeof value !== 'string') {
-        throw new Error('Value must be a string');
-      }
-      if (min !== undefined && value.length < min) {
-        throw new Error(`String must be at least ${min} characters`);
-      }
-      if (max !== undefined && value.length > max) {
-        throw new Error(`String must be at most ${max} characters`);
-      }
-    },
-  );
-};
-
-/**
- * Factory function to create a bounded integer scalar
- * @param {string} name - Name for the scalar
- * @param {number} min - Minimum value
- * @param {number} max - Maximum value
- * @returns {GraphQLScalarType} A scalar type with range validation
- */
-export const createBoundedIntScalar = (name, min, max) => {
-  return createValidatedScalar(
-    name,
-    `An integer between ${min} and ${max}`,
-    GraphQLInt,
-    (value) => {
-      if (typeof value !== 'number' || isNaN(value)) {
-        throw new Error('Value must be a number');
-      }
-      if (min !== undefined && value < min) {
-        throw new Error(`Value must be at least ${min}`);
-      }
-      if (max !== undefined && value > max) {
-        throw new Error(`Value must be at most ${max}`);
-      }
-    },
-  );
-};
-
-/**
- * Factory function to create a bounded float scalar
- * @param {string} name - Name for the scalar
- * @param {number} min - Minimum value
- * @param {number} max - Maximum value
- * @returns {GraphQLScalarType} A scalar type with range validation
- */
-export const createBoundedFloatScalar = (name, min, max) => {
-  return createValidatedScalar(
-    name,
-    `A float between ${min} and ${max}`,
-    GraphQLFloat,
-    (value) => {
-      if (typeof value !== 'number' || isNaN(value)) {
-        throw new Error('Value must be a number');
-      }
-      if (min !== undefined && value < min) {
-        throw new Error(`Value must be at least ${min}`);
-      }
-      if (max !== undefined && value > max) {
-        throw new Error(`Value must be at most ${max}`);
-      }
-    },
-  );
-};
-
-/**
- * Factory function to create a regex pattern string scalar
- * @param {string} name - Name for the scalar
- * @param {RegExp|string} pattern - Regex pattern to validate against
- * @param {string} message - Error message if validation fails
- * @returns {GraphQLScalarType} A scalar type with pattern validation
- */
-export const createPatternStringScalar = (name, pattern, message) => {
-  const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
-  const errorMessage = message || 'Value does not match required pattern';
-
-  return createValidatedScalar(
-    name,
-    `A string matching the pattern: ${pattern}`,
-    GraphQLString,
-    (value) => {
-      if (typeof value !== 'string') {
-        throw new Error('Value must be a string');
-      }
-      if (!regex.test(value)) {
-        throw new Error(errorMessage);
-      }
-    },
-  );
-};
-
-// Export all scalars as an object for convenience
-const scalars = {
-  // Pre-built scalars
-  EmailScalar,
-  URLScalar,
-  PositiveIntScalar,
-  PositiveFloatScalar,
-  // Factory functions
-  createBoundedStringScalar,
-  createBoundedIntScalar,
-  createBoundedFloatScalar,
-  createPatternStringScalar,
-};
-
-export default scalars;
-
+export * from '@simtlix/simfinity-core/scalars';
+export { default } from '@simtlix/simfinity-core/scalars';

package/src/validators.js

@@ -1,250 +1,2 @@
-import SimfinityError from './errors/simfinity.error.js';
-
-/**
- * Creates a validation object that works for both 'save' (CREATE) and 'update' (UPDATE) operations.
- * The validators will be applied to both operations.
- * For CREATE operations, the value must be provided and valid.
- * For UPDATE operations, undefined/null values are allowed (field might not be updated),
- * but if a value is provided, it must be valid.
- */
-const createValidator = (validatorFn, required = false) => {
-  // Validator for CREATE operations - value is required if required=true
-  const validateCreate = async (typeName, fieldName, value, session) => {
-    if (required && (value === null || value === undefined)) {
-      throw new SimfinityError(`${fieldName} is required`, 'VALIDATION_ERROR', 400);
-    }
-    if (value !== null && value !== undefined) {
-      await validatorFn(typeName, fieldName, value, session);
-    }
-  };
-
-  // Validator for UPDATE operations - value is optional
-  const validateUpdate = async (typeName, fieldName, value, session) => {
-    // Skip validation if value is not provided (field is not being updated)
-    if (value === null || value === undefined) {
-      return;
-    }
-    // If value is provided, validate it
-    await validatorFn(typeName, fieldName, value, session);
-  };
-
-  const validatorCreate = { validate: validateCreate };
-  const validatorUpdate = { validate: validateUpdate };
-  
-  // Return validations for both CREATE and UPDATE operations
-  // Also support 'save'/'update' for backward compatibility (though code uses CREATE/UPDATE)
-  return {
-    CREATE: [validatorCreate],
-    UPDATE: [validatorUpdate],
-    save: [validatorCreate], // For backward compatibility
-    update: [validatorUpdate], // For backward compatibility
-  };
-};
-
-/**
- * String validators
- */
-export const stringLength = (name, min, max) => {
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'string') {
-      throw new SimfinityError(`${name} must be a string`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (min !== undefined && value.length < min) {
-      throw new SimfinityError(`${name} must be at least ${min} characters`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (max !== undefined && value.length > max) {
-      throw new SimfinityError(`${name} must be at most ${max} characters`, 'VALIDATION_ERROR', 400);
-    }
-  }, true); // Required for CREATE operations
-};
-
-export const maxLength = (name, max) => {
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'string') {
-      throw new SimfinityError(`${name} must be a string`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (value.length > max) {
-      throw new SimfinityError(`${name} must be at most ${max} characters`, 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-export const pattern = (name, regex, message) => {
-  const regexObj = typeof regex === 'string' ? new RegExp(regex) : regex;
-  const errorMessage = message || `${name} format is invalid`;
-  
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'string') {
-      throw new SimfinityError(`${name} must be a string`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (!regexObj.test(value)) {
-      throw new SimfinityError(errorMessage, 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-export const email = () => {
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'string') {
-      throw new SimfinityError('Email must be a string', 'VALIDATION_ERROR', 400);
-    }
-    
-    if (!emailRegex.test(value)) {
-      throw new SimfinityError('Invalid email format', 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-export const url = () => {
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'string') {
-      throw new SimfinityError('URL must be a string', 'VALIDATION_ERROR', 400);
-    }
-    
-    try {
-      // Use URL constructor for better validation
-      new URL(value);
-    } catch (e) {
-        console.log('Invalid URL format', e);
-      throw new SimfinityError('Invalid URL format', 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-/**
- * Number validators
- */
-export const numberRange = (name, min, max) => {
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'number' || isNaN(value)) {
-      throw new SimfinityError(`${name} must be a number`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (min !== undefined && value < min) {
-      throw new SimfinityError(`${name} must be at least ${min}`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (max !== undefined && value > max) {
-      throw new SimfinityError(`${name} must be at most ${max}`, 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-export const positive = (name) => {
-  return createValidator(async (typeName, fieldName, value) => {
-    if (typeof value !== 'number' || isNaN(value)) {
-      throw new SimfinityError(`${name} must be a number`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (value <= 0) {
-      throw new SimfinityError(`${name} must be positive`, 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-/**
- * Array validators
- */
-export const arrayLength = (name, maxItems, itemValidator) => {
-  return createValidator(async (typeName, fieldName, value, session) => {
-    if (!Array.isArray(value)) {
-      throw new SimfinityError(`${name} must be an array`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (maxItems !== undefined && value.length > maxItems) {
-      throw new SimfinityError(`${name} must have at most ${maxItems} items`, 'VALIDATION_ERROR', 400);
-    }
-    
-    // If itemValidator is provided, validate each item
-    if (itemValidator && Array.isArray(itemValidator)) {
-      for (let i = 0; i < value.length; i++) {
-        for (const validator of itemValidator) {
-          await validator.validate(typeName, fieldName, value[i], session);
-        }
-      }
-    }
-  }, false); // Optional
-};
-
-/**
- * Date validators
- */
-export const dateFormat = (name, format) => {
-  return createValidator(async (typeName, fieldName, value) => {
-    // Handle Date objects, ISO strings, and timestamps
-    let date;
-    if (value instanceof Date) {
-      date = value;
-    } else if (typeof value === 'string') {
-      date = new Date(value);
-    } else if (typeof value === 'number') {
-      date = new Date(value);
-    } else {
-      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (isNaN(date.getTime())) {
-      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
-    }
-    
-    // If format is provided, validate format
-    if (format && typeof value === 'string') {
-      // Simple format validation - can be enhanced
-      const formatRegex = /^\d{4}-\d{2}-\d{2}$/; // YYYY-MM-DD
-      if (format === 'YYYY-MM-DD' && !formatRegex.test(value)) {
-        throw new SimfinityError(`${name} must be in format ${format}`, 'VALIDATION_ERROR', 400);
-      }
-      // Add more format patterns as needed
-    }
-  }, false); // Optional
-};
-
-export const futureDate = (name) => {
-  return createValidator(async (typeName, fieldName, value) => {
-    let date;
-    if (value instanceof Date) {
-      date = value;
-    } else if (typeof value === 'string') {
-      date = new Date(value);
-    } else if (typeof value === 'number') {
-      date = new Date(value);
-    } else {
-      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (isNaN(date.getTime())) {
-      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
-    }
-    
-    if (date <= new Date()) {
-      throw new SimfinityError(`${name} must be a future date`, 'VALIDATION_ERROR', 400);
-    }
-  }, false); // Optional
-};
-
-// Export all validators as an object
-const validators = {
-  // String validators
-  stringLength,
-  maxLength,
-  pattern,
-  email,
-  url,
-  // Number validators
-  numberRange,
-  positive,
-  // Array validators
-  arrayLength,
-  // Date validators
-  dateFormat,
-  futureDate,
-};
-
-export default validators;
-
+export * from '@simtlix/simfinity-core/validators';
+export { default } from '@simtlix/simfinity-core/validators';

package/types/index.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Type declarations for @simtlix/simfinity-js.
+ *
+ * Mirrors the MongoDB facade in src/index.js. Shared helper and MCP types are
+ * re-exported from their canonical packages; MongoDB model and session values
+ * remain deliberately typed loosely (`any`).
+ */
+
+import type {
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLInputObjectType,
+  GraphQLOutputType,
+} from 'graphql';
+import type {
+  DatabaseAdapter,
+  RuntimeRegistration,
+  SimfinityError,
+} from '@simtlix/simfinity-core';
+export {
+  auth,
+  buildErrorFormatter,
+  createRuntime,
+  createValidatedScalar,
+  InternalServerError,
+  plugins,
+  scalars,
+  SimfinityError,
+  validators,
+} from '@simtlix/simfinity-core';
+export type {
+  AuthPluginOptions,
+  AuthRule,
+  AuthRuleFunction,
+  EnvelopSchemaPlugin,
+  FieldValidations,
+  FieldValidator,
+  PermissionSchema,
+  PolicyExpression,
+  TypePermissions,
+} from '@simtlix/simfinity-core';
+export * from '@simtlix/simfinity-mcp';
+export { default as mcp } from '@simtlix/simfinity-mcp';
+export function createMongoAdapter(): DatabaseAdapter;
+export function getRegistrations(): RuntimeRegistration[];
+
+/* ========================================================================== *
+ * Core schema-building API (src/index.js)
+ * ========================================================================== */
+
+/** Lifecycle hooks run before commit and may repeat on a transient transaction retry. */
+export interface EntityController {
+  onSaving?(doc: any, args: any, session: any, context: any): void | Promise<void>;
+  onSaved?(result: any, args: any, session: any, context: any): void | Promise<void>;
+  onUpdating?(id: any, args: any, session: any, context: any): void | Promise<void>;
+  /** Receives the updated Mongoose document after parent and nested writes complete. */
+  onUpdated?(result: any, session: any, context: any): void | Promise<void>;
+  onDelete?(doc: any, session: any, context: any): void | Promise<void>;
+}
+
+/** State machine attached to an entity (initial state plus named action transitions). */
+export interface StateMachine {
+  initialState: any;
+  actions: Record<string, any>;
+  [key: string]: any;
+}
+
+/** Register a Mongoose model + GraphQL type pair, exposing single and list endpoints. */
+export function connect(
+  model: any,
+  gqltype: GraphQLObjectType,
+  simpleEntityEndpointName: string,
+  listEntitiesEndpointName: string,
+  controller?: EntityController | null,
+  onModelCreated?: ((model: any) => void) | null,
+  stateMachine?: StateMachine | null,
+): void;
+
+/** Register a GraphQL type without exposing root endpoints (e.g. embedded/related types). */
+export function addNoEndpointType(gqltype: GraphQLObjectType): void;
+
+/**
+ * Build the executable GraphQLSchema from every connected type. The first two
+ * allowlists are matched against the GraphQLObjectType INSTANCES passed to
+ * connect(); only custom mutations are matched by name.
+ */
+export function createSchema(
+  includedQueryTypes?: GraphQLObjectType[] | null,
+  includedMutationTypes?: GraphQLObjectType[] | null,
+  includedCustomMutations?: string[] | null,
+): GraphQLSchema;
+
+/** Register a custom mutation executed inside a transaction. */
+export function registerMutation(
+  name: string,
+  description: string,
+  inputModel: GraphQLInputObjectType | null | undefined,
+  outputModel: GraphQLOutputType,
+  callback: (input: any, session: any, context: any) => any,
+): void;
+
+/** Operation context for root operations, generated non-embedded relation reads, and nested collection writes. */
+export interface SimfinityMiddlewareContext {
+  args: any;
+  operation: string;
+  entry?: string;
+  type?: any;
+  context?: any;
+  [key: string]: any;
+}
+
+/**
+ * Register middleware before generated operations, including related-type reads and nested child writes.
+ * Nested operations keep root argument shapes and the GraphQL request context.
+ * Await next() to advance the middleware chain; throw to reject before the operation executes.
+ */
+export function use(
+  middleware: (
+    context: SimfinityMiddlewareContext,
+    next: () => Promise<void>,
+  ) => void | Promise<void>,
+): void;
+
+/** Globally prevent Mongoose collection creation for generated models. */
+export function preventCreatingCollection(prevent: boolean): void;
+
+/** Process-wide limits for generated list and paginated aggregate queries. */
+export interface QueryLimitsOptions {
+  /** Positive safe integer; defaults to 1000. Unpaged lists use min(100, maxPageSize). */
+  maxPageSize?: number;
+}
+
+/** Configure at startup. Invalid configuration throws INVALID_QUERY_LIMITS (400). */
+export function configureQueryLimits(options?: QueryLimitsOptions): void;
+
+/**
+ * Get the generated create input type, preserving field and list-item non-null
+ * wrappers. Update inputs remove only the outer wrapper (except entity id).
+ * References use IdInputType; embedded lists use nested inputs; referenced
+ * collections use added/updated/deleted operation inputs.
+ */
+export function getInputType(type: GraphQLObjectType | { name: string }): GraphQLInputObjectType;
+
+/**
+ * Persist an object and its nested writes inside a transaction (runs controllers/validators).
+ * Without a session, owns a transaction on the model's connection and awaits cleanup.
+ * A supplied session must have an active transaction and belong to the model's MongoDB client.
+ * The caller then owns retries, commit, abort, and cleanup; inactive sessions are rejected.
+ * Owned transactions retry transient failures and uncertain commits separately, up to five times each.
+ */
+
+export function saveObject(
+  typeName: string,
+  args: Record<string, any>,
+  session?: any,
+  context?: any,
+): Promise<any>;
+
+/** Get the Mongoose model registered for a connected GraphQL type. */
+export function getModel(gqltype: GraphQLObjectType | { name: string }): any;
+
+/** Look up a connected GraphQL type by name (or by another type's name). */
+export function getType(
+  typeName: string | { name: string },
+): GraphQLObjectType | null | undefined;
+
+/* ========================================================================== *
+ * Query building (src/index.js)
+ * ========================================================================== */
+
+/** A QLFilterGroup input value (recursive AND/OR groups plus flat conditions). */
+export interface FilterGroupInput {
+  AND?: FilterGroupInput[];
+  OR?: FilterGroupInput[];
+  conditions?: Array<{
+    field: string;
+    operator?: string;
+    value?: any;
+    path?: string;
+  }>;
+  [key: string]: any;
+}
+
+/** Translate list-query arguments (filters, AND/OR, sort, pagination) into a MongoDB aggregation pipeline. */
+export function buildQuery(
+  input: Record<string, any>,
+  gqltype: GraphQLObjectType,
+  isCount?: boolean,
+): Promise<Array<Record<string, any>>>;
+
+/** Translate a QLFilterGroup into a MongoDB `$match` expression, collecting required lookups. */
+export function buildFilterGroupMatch(
+  filterGroup: FilterGroupInput,
+  gqltype: GraphQLObjectType,
+  aggregateClauses: any[],
+  aggregationsIncluded: Record<string, any>,
+  depth?: number,
+): Promise<any>;