json-rest-api 1.0.0 → 1.0.1

package/schema.js

@@ -1,481 +0,0 @@
-import { stringify as serialize, parse as deserialize } from 'circular-json-es6';
-
-/**
- * Schema class for validating and transforming data with plugin support
- */
-export class Schema {
-  constructor(structure = {}, options = {}) {
-    this.structure = structure;
-    this.options = options;
-    this.plugins = [];
-    this.types = new Map();
-    this.params = new Map();
-    this._initializeBuiltins();
-  }
-
-  /**
-   * Add a plugin to the schema
-   */
-  use(plugin, options = {}) {
-    if (typeof plugin.install === 'function') {
-      plugin.install(this, options);
-    }
-    this.plugins.push({ plugin, options });
-    return this;
-  }
-
-  /**
-   * Register a custom type handler
-   */
-  registerType(name, handler) {
-    this.types.set(name, handler);
-    return this;
-  }
-
-  /**
-   * Register a custom parameter handler
-   */
-  registerParam(name, handler) {
-    this.params.set(name, handler);
-    return this;
-  }
-
-  /**
-   * Initialize built-in types and parameters
-   */
-  _initializeBuiltins() {
-    // Built-in types
-    this.registerType('none', this._noneType);
-    this.registerType('string', this._stringType);
-    this.registerType('blob', this._blobType);
-    this.registerType('number', this._numberType);
-    this.registerType('timestamp', this._timestampType);
-    this.registerType('dateTime', this._dateTimeType);
-    this.registerType('date', this._dateType);
-    this.registerType('array', this._arrayType);
-    this.registerType('object', this._objectType);
-    this.registerType('serialize', this._serializeType);
-    this.registerType('boolean', this._booleanType);
-    this.registerType('id', this._idType);
-
-    // Built-in parameters
-    this.registerParam('required', this._requiredParam);
-    this.registerParam('min', this._minParam);
-    this.registerParam('max', this._maxParam);
-    this.registerParam('validator', this._validatorParam);
-    this.registerParam('uppercase', this._uppercaseParam);
-    this.registerParam('lowercase', this._lowercaseParam);
-    this.registerParam('trim', this._trimParam);
-    this.registerParam('length', this._lengthParam);
-    this.registerParam('default', this._defaultParam);
-    this.registerParam('notEmpty', this._notEmptyParam);
-  }
-
-  /**
-   * Validate an object against the schema
-   */
-  async validate(object, options = {}) {
-    const errors = [];
-    const validatedObject = { ...object };
-
-    // Check for unknown fields unless we're only validating object values
-    if (!options.onlyObjectValues) {
-      for (const fieldName in object) {
-        if (!this.structure[fieldName]) {
-          errors.push({
-            field: fieldName,
-            message: 'Field not allowed',
-            code: 'FIELD_NOT_ALLOWED'
-          });
-        }
-      }
-    }
-
-    // Determine target object for validation
-    const targetObject = options.onlyObjectValues ? object : this.structure;
-
-    for (const fieldName in targetObject) {
-      const definition = this.structure[fieldName];
-      if (!definition) continue;
-
-      let skipCast = false;
-      let skipParams = false;
-
-      // Get field options
-      const canBeNull = this._getCanBeNull(definition, options);
-      const emptyAsNull = this._getEmptyAsNull(definition, options);
-
-      // Handle required fields
-      if (definition.required && object[fieldName] === undefined) {
-        if (!this._skipParam('required', options.skipParams, fieldName)) {
-          const errorMessage = definition.requiredErrorMessage || 
-                             definition.errorMessage || 
-                             'Field required';
-          errors.push({
-            field: fieldName,
-            message: errorMessage,
-            code: 'FIELD_REQUIRED'
-          });
-          skipParams = true;
-        }
-      }
-
-      // Skip casting if not required and undefined
-      if (!definition.required && object[fieldName] === undefined) {
-        skipCast = true;
-      }
-
-      // Handle empty strings
-      if (String(object[fieldName]) === '' && emptyAsNull) {
-        validatedObject[fieldName] = null;
-        skipParams = true;
-      }
-
-      // Handle null values
-      if (object[fieldName] === null) {
-        if (!canBeNull) {
-          const errorMessage = definition.nullErrorMessage || 
-                             definition.errorMessage || 
-                             'Field cannot be null';
-          errors.push({
-            field: fieldName,
-            message: errorMessage,
-            code: 'FIELD_CANNOT_BE_NULL'
-          });
-        }
-        skipParams = true;
-      }
-
-      // Type casting
-      if (!skipCast && !skipParams && this.types.has(definition.type)) {
-        try {
-          const typeHandler = this.types.get(definition.type);
-          const result = await typeHandler.call(this, {
-            definition,
-            value: object[fieldName],
-            fieldName,
-            object: validatedObject,
-            objectBeforeCast: object,
-            valueBeforeCast: object[fieldName],
-            options,
-            computedOptions: { canBeNull, emptyAsNull }
-          });
-          if (result !== undefined) {
-            validatedObject[fieldName] = result;
-          }
-        } catch (error) {
-          const errorMessage = definition.errorMessage || 
-                             definition.castErrorMessage || 
-                             error.message || 
-                             'Type casting failed';
-          errors.push({
-            field: fieldName,
-            message: errorMessage,
-            code: 'TYPE_ERROR'
-          });
-        }
-      }
-
-      // Parameter validation
-      if (!skipParams) {
-        for (const paramName in definition) {
-          if (paramName === 'type' || 
-              this._skipParam(paramName, options.skipParams, fieldName)) {
-            continue;
-          }
-
-          if (this.params.has(paramName)) {
-            try {
-              const paramHandler = this.params.get(paramName);
-              const result = await paramHandler.call(this, {
-                definition,
-                value: validatedObject[fieldName],
-                fieldName,
-                object: validatedObject,
-                objectBeforeCast: object,
-                valueBeforeCast: object[fieldName],
-                parameterName: paramName,
-                parameterValue: definition[paramName],
-                options,
-                computedOptions: { canBeNull, emptyAsNull }
-              });
-              if (result !== undefined) {
-                validatedObject[fieldName] = result;
-              }
-            } catch (error) {
-              // Support parameter-specific error messages
-              const paramErrorKey = `${paramName}ErrorMessage`;
-              const errorMessage = definition[paramErrorKey] || 
-                                 definition.errorMessage || 
-                                 error.message || 
-                                 'Parameter validation failed';
-              errors.push({
-                field: fieldName,
-                message: errorMessage,
-                code: 'PARAM_ERROR'
-              });
-            }
-          }
-        }
-      }
-    }
-
-    return { validatedObject, errors };
-  }
-
-  /**
-   * Clean up an object to only include fields with a specific parameter
-   */
-  cleanup(object, parameterName) {
-    const cleanedObject = {};
-    for (const key in object) {
-      if (this.structure[key] && this.structure[key][parameterName]) {
-        cleanedObject[key] = object[key];
-      }
-    }
-    return cleanedObject;
-  }
-
-  /**
-   * Helper method to validate with onlyObjectValues option
-   * Useful for partial updates
-   */
-  async validatePartial(object, options = {}) {
-    return this.validate(object, { ...options, onlyObjectValues: true });
-  }
-
-  // Built-in type handlers
-  _noneType({ value }) {
-    return value;
-  }
-
-  _stringType({ value, definition }) {
-    if (value === undefined || value === null) return '';
-    if (typeof value.toString !== 'function') {
-      throw new Error('Cannot cast to string');
-    }
-    const str = value.toString();
-    return definition.noTrim ? str : str.trim();
-  }
-
-  _blobType({ value }) {
-    return value;
-  }
-
-  _numberType({ value }) {
-    if (value === undefined) return 0;
-    const num = Number(value);
-    if (isNaN(num)) {
-      throw new Error('Invalid number');
-    }
-    return num;
-  }
-
-  _timestampType({ value, computedOptions }) {
-    const num = Number(value);
-    if (isNaN(num)) {
-      throw new Error('Invalid timestamp');
-    }
-    if (!num && computedOptions.canBeNull) return null;
-    return num;
-  }
-
-  _dateTimeType({ value }) {
-    if (!value) return null;
-    const date = new Date(value);
-    if (isNaN(date.getTime())) {
-      throw new Error('Invalid date');
-    }
-    return date.toISOString().slice(0, 19).replace('T', ' ');
-  }
-
-  _dateType(params) {
-    const result = this._dateTimeType(params);
-    return result ? result.slice(0, 10) : result;
-  }
-
-  _arrayType({ value }) {
-    return Array.isArray(value) ? value : [value];
-  }
-
-  _objectType({ value }) {
-    return value;
-  }
-
-  _serializeType({ value }) {
-    try {
-      return serialize(value);
-    } catch (error) {
-      throw new Error('Serialization failed');
-    }
-  }
-
-  _booleanType({ value, definition }) {
-    if (typeof value === 'string') {
-      const falseValue = definition.stringFalseWhen || 'false';
-      const trueValue = definition.stringTrueWhen || 'true';
-      if (value === falseValue) return false;
-      if (value === trueValue || value === 'on') return true;
-      return false;
-    }
-    return !!value;
-  }
-
-  _idType({ value }) {
-    const num = parseInt(value, 10);
-    if (isNaN(num)) {
-      throw new Error('Invalid ID');
-    }
-    return num;
-  }
-
-  // Built-in parameter handlers
-  _requiredParam({ value, fieldName }) {
-    if (value === undefined || value === null) {
-      throw new Error(`${fieldName} is required`);
-    }
-  }
-
-  _minParam({ value, parameterValue, definition, fieldName }) {
-    if (value === undefined) return;
-    if (definition.type === 'number' && value < parameterValue) {
-      const errorMessage = definition.minErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} is too low`;
-      throw new Error(errorMessage);
-    }
-    if (definition.type === 'string' && value.length < parameterValue) {
-      const errorMessage = definition.minErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} is too short`;
-      throw new Error(errorMessage);
-    }
-    if (definition.type === 'array' && value.length < parameterValue) {
-      const errorMessage = definition.minErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} must have at least ${parameterValue} items`;
-      throw new Error(errorMessage);
-    }
-  }
-
-  _maxParam({ value, parameterValue, definition, fieldName }) {
-    if (value === undefined) return;
-    if (definition.type === 'number' && value > parameterValue) {
-      const errorMessage = definition.maxErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} is too high`;
-      throw new Error(errorMessage);
-    }
-    if (definition.type === 'string' && value.length > parameterValue) {
-      const errorMessage = definition.maxErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} is too long`;
-      throw new Error(errorMessage);
-    }
-    if (definition.type === 'array' && value.length > parameterValue) {
-      const errorMessage = definition.maxErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} must have at most ${parameterValue} items`;
-      throw new Error(errorMessage);
-    }
-  }
-
-  _validatorParam({ parameterValue, value, object, fieldName, definition }) {
-    if (typeof parameterValue !== 'function') {
-      throw new Error('Validator must be a function');
-    }
-    
-    // Support custom validator with custom error message
-    const validatorResult = parameterValue(value, object, { 
-      schema: this, 
-      fieldName,
-      definition 
-    });
-    
-    // Handle different return types
-    if (validatorResult === false) {
-      // Use custom error message if provided
-      const errorMessage = definition.validatorMessage || 
-                          definition.errorMessage || 
-                          `Validation failed for ${fieldName}`;
-      throw new Error(errorMessage);
-    } else if (typeof validatorResult === 'string') {
-      // Validator returned a custom error message
-      throw new Error(validatorResult);
-    } else if (validatorResult instanceof Error) {
-      throw validatorResult;
-    }
-    // If result is true or undefined, validation passed
-  }
-
-  _uppercaseParam({ value, definition }) {
-    if (definition.type === 'string' && typeof value === 'string') {
-      return value.toUpperCase();
-    }
-  }
-
-  _lowercaseParam({ value, definition }) {
-    if (definition.type === 'string' && typeof value === 'string') {
-      return value.toLowerCase();
-    }
-  }
-
-  _trimParam({ value, parameterValue, definition, fieldName, valueBeforeCast }) {
-    if (definition.type === 'string' && typeof value === 'string') {
-      return value.slice(0, parameterValue);
-    }
-    if (Number.isInteger(Number(valueBeforeCast)) && 
-        String(Number(valueBeforeCast)).length > parameterValue) {
-      throw new Error(`${fieldName} out of range`);
-    }
-  }
-
-  _lengthParam(params) {
-    return this._trimParam(params);
-  }
-
-  _defaultParam({ valueBeforeCast, parameterValue, object, fieldName, definition }) {
-    if (valueBeforeCast === undefined) {
-      if (typeof parameterValue === 'function') {
-        // Pass context to default function for conditional defaults
-        return parameterValue({
-          object,
-          fieldName,
-          definition,
-          schema: this
-        });
-      }
-      return parameterValue;
-    }
-  }
-
-  _notEmptyParam({ valueBeforeCast, parameterValue, fieldName, definition }) {
-    const str = valueBeforeCast?.toString ? valueBeforeCast.toString() : '';
-    if (parameterValue && valueBeforeCast !== undefined && str === '') {
-      const errorMessage = definition.notEmptyErrorMessage || 
-                         definition.errorMessage || 
-                         `${fieldName} cannot be empty`;
-      throw new Error(errorMessage);
-    }
-  }
-
-  // Helper methods
-  _skipParam(param, skipParams, field) {
-    if (!skipParams || typeof skipParams !== 'object') return false;
-    const fieldSkips = skipParams[field];
-    return Array.isArray(fieldSkips) && fieldSkips.includes(param);
-  }
-
-  _getCanBeNull(definition, options) {
-    if (definition.default === null) return true;
-    if (typeof definition.canBeNull !== 'undefined') return definition.canBeNull;
-    if (typeof options.canBeNull !== 'undefined') return !!options.canBeNull;
-    return false;
-  }
-
-  _getEmptyAsNull(definition, options) {
-    if (typeof definition.emptyAsNull !== 'undefined') return definition.emptyAsNull;
-    if (typeof options.emptyAsNull !== 'undefined') return !!options.emptyAsNull;
-    return false;
-  }
-}

package/test-basic.js

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-
-import { createApi, Schema } from './index.js';
-
-console.log('Testing basic jsonrestapi functionality...\n');
-
-// Test 1: Create simple API with memory storage
-console.log('1. Creating API with memory storage...');
-const api = createApi({
-  storage: 'memory',
-  http: {
-    basePath: '/api/v1'
-  }
-});
-console.log('✓ API created successfully');
-
-// Test 2: Define and register schema
-console.log('\n2. Creating and registering user schema...');
-const userSchema = new Schema({
-  id: { type: 'id' },
-  name: { type: 'string', required: true },
-  email: { type: 'string', required: true },
-  age: { type: 'number', min: 0, max: 150 }
-});
-
-// Define hooks for users
-const userHooks = {
-  async transformResult(context) {
-    // Add a test field to verify hooks work
-    if (context.result) {
-      context.result.testField = 'hooks-working';
-    }
-  }
-};
-
-api.addResource('users', userSchema, userHooks);
-console.log('✓ Schema registered successfully with hooks');
-
-// Test 3: Insert data
-console.log('\n3. Testing insert operation...');
-try {
-  const newUser = await api.insert({
-    name: 'John Doe',
-    email: 'john@example.com',
-    age: 30
-  }, {
-    type: 'users'
-  });
-  
-  console.log('✓ User created:', newUser.data);
-} catch (error) {
-  console.error('✗ Insert failed:', error.message);
-}
-
-// Test 4: Query data
-console.log('\n4. Testing query operation...');
-try {
-  const result = await api.query({
-    filter: { age: 30 }
-  }, {
-    type: 'users'
-  });
-  
-  console.log('✓ Query successful. Found', result.meta.total, 'users');
-} catch (error) {
-  console.error('✗ Query failed:', error.message);
-}
-
-// Test 5: Get by ID
-console.log('\n5. Testing get operation...');
-try {
-  const user = await api.get(1, {
-    type: 'users'
-  });
-  
-  console.log('✓ User retrieved:', user.data);
-} catch (error) {
-  console.error('✗ Get failed:', error.message);
-}
-
-// Test 6: Update
-console.log('\n6. Testing update operation...');
-try {
-  const updated = await api.update(1, {
-    age: 31
-  }, {
-    type: 'users'
-  });
-  
-  console.log('✓ User updated:', updated.data);
-} catch (error) {
-  console.error('✗ Update failed:', error.message);
-}
-
-// Test 7: Delete
-console.log('\n7. Testing delete operation...');
-try {
-  await api.delete(1, {
-    type: 'users'
-  });
-  
-  console.log('✓ User deleted successfully');
-} catch (error) {
-  console.error('✗ Delete failed:', error.message);
-}
-
-console.log('\n✓ All basic tests completed!');