json-rest-api 1.0.14 → 1.0.15

package/plugins/core/lib/dbTablesOperations.js

@@ -9,50 +9,50 @@
  * @param {object} definition - The schema definition for the field
  * @returns {object} The Knex column builder instance
  */
-function mapTypeToKnex(table, columnName, definition) {
-  const { type, precision, scale, maxLength, unsigned } = definition;
-  
+function mapTypeToKnex (table, columnName, definition) {
+  const { type, precision, scale, maxLength, unsigned } = definition
+
   switch (type) {
     case 'string':
-      return maxLength ? table.string(columnName, maxLength) : table.string(columnName);
-    
+      return maxLength ? table.string(columnName, maxLength) : table.string(columnName)
+
     case 'number':
       if (precision !== undefined && scale !== undefined) {
-        return table.decimal(columnName, precision, scale);
+        return table.decimal(columnName, precision, scale)
       }
-      return table.float(columnName);
-    
+      return table.float(columnName)
+
     case 'id':
-      const col = table.integer(columnName);
-      return unsigned !== false ? col.unsigned() : col;
-    
+      const col = table.integer(columnName)
+      return unsigned !== false ? col.unsigned() : col
+
     case 'boolean':
-      return table.boolean(columnName);
-    
+      return table.boolean(columnName)
+
     case 'date':
-      return table.date(columnName);
-    
+      return table.date(columnName)
+
     case 'dateTime':
-      return table.datetime(columnName);
-    
+      return table.datetime(columnName)
+
     case 'time':
-      return table.time(columnName);
-    
+      return table.time(columnName)
+
     case 'timestamp':
-      return table.integer(columnName);
-    
+      return table.integer(columnName)
+
     case 'array':
     case 'object':
     case 'serialize':
-      return table.json(columnName);
-    
+      return table.json(columnName)
+
     case 'blob':
     case 'file':
-      return table.binary(columnName);
-    
+      return table.binary(columnName)
+
     case 'none':
     default:
-      return table.string(columnName);
+      return table.string(columnName)
   }
 }
 
@@ -61,47 +61,47 @@ function mapTypeToKnex(table, columnName, definition) {
  * @param {object} column - The Knex column builder instance
  * @param {object} definition - The schema definition for the field
  */
-function applyConstraints(column, definition) {
+function applyConstraints (column, definition) {
   // Nullability
   if (definition.nullable === true) {
-    column.nullable();
+    column.nullable()
   } else if (definition.required === true || definition.nullable === false) {
-    column.notNullable();
+    column.notNullable()
   }
-  
+
   // Default value
   if (definition.defaultTo !== undefined) {
-    column.defaultTo(definition.defaultTo);
+    column.defaultTo(definition.defaultTo)
   }
-  
+
   // Database-specific constraints
   if (definition.unique === true) {
-    column.unique();
+    column.unique()
   }
-  
+
   if (definition.primary === true) {
-    column.primary();
+    column.primary()
   }
-  
+
   if (definition.index === true) {
-    column.index();
+    column.index()
   }
-  
+
   if (definition.references) {
     column.references(definition.references.column || 'id')
-      .inTable(definition.references.table);
-    
+      .inTable(definition.references.table)
+
     if (definition.references.onDelete) {
-      column.onDelete(definition.references.onDelete);
+      column.onDelete(definition.references.onDelete)
     }
-    
+
     if (definition.references.onUpdate) {
-      column.onUpdate(definition.references.onUpdate);
+      column.onUpdate(definition.references.onUpdate)
     }
   }
-  
+
   if (definition.comment) {
-    column.comment(definition.comment);
+    column.comment(definition.comment)
   }
 }
 
@@ -116,9 +116,8 @@ function applyConstraints(column, definition) {
  * @param {boolean} [options.timestamps=false] - Whether to add created_at/updated_at columns
  * @returns {Promise} A promise that resolves when the table is created
  */
-export async function createKnexTable(knex, schemaInfo, tableSchemaInstance,  options = {}) {
-  const { autoIncrement = true, timestamps = false } = options;
-  
+export async function createKnexTable (knex, schemaInfo, tableSchemaInstance, options = {}) {
+  const { autoIncrement = true, timestamps = false } = options
 
   const tableName = schemaInfo.tableName
   const idProperty = schemaInfo.idProperty
@@ -126,57 +125,57 @@ export async function createKnexTable(knex, schemaInfo, tableSchemaInstance,  op
 
   return knex.schema.createTable(tableName, (table) => {
     // Check if schema has the idProperty field with primary key
-    const hasIdField = tableSchemaStructure[idProperty] && tableSchemaStructure[idProperty].primary === true;
-    
+    const hasIdField = tableSchemaStructure[idProperty] && tableSchemaStructure[idProperty].primary === true
+
     // Add auto-incrementing ID if no primary key is defined and autoIncrement is true
     if (!hasIdField && autoIncrement) {
-      table.increments(idProperty).primary();
+      table.increments(idProperty).primary()
     }
-    
+
     // Process each field in the schema
     for (const [fieldName, definition] of Object.entries(tableSchemaStructure)) {
       // Skip if this is the ID field and we already handled it
       if (fieldName === idProperty && !hasIdField && autoIncrement) {
-        continue;
+        continue
       }
-      
+
       // Create the column with the appropriate type
-      const column = mapTypeToKnex(table, fieldName, definition);
-      
+      const column = mapTypeToKnex(table, fieldName, definition)
+
       // Apply constraints
-      applyConstraints(column, definition);
+      applyConstraints(column, definition)
     }
-    
+
     // Add timestamps if requested
     if (timestamps) {
-      table.timestamps(true, true);
+      table.timestamps(true, true)
     }
-  });
+  })
 }
 
-export async function addKnexFields(knex, tableName, schema) {  
+export async function addKnexFields (knex, tableName, schema) {
   return knex.schema.alterTable(tableName, (table) => {
-    for (const [fieldName, definition] of Object.entries(schema.structure)) {   
-      const column = mapTypeToKnex(table, fieldName, definition);      
-      applyConstraints(column, definition);
+    for (const [fieldName, definition] of Object.entries(schema.structure)) {
+      const column = mapTypeToKnex(table, fieldName, definition)
+      applyConstraints(column, definition)
     }
-  });
+  })
 }
 
 // Helper function to alter multiple fields in an existing table
-export async function alterKnexFields(knex, tableName, fields, options = {}) {
+export async function alterKnexFields (knex, tableName, fields, options = {}) {
   return knex.schema.alterTable(tableName, (table) => {
     for (const [fieldName, definition] of Object.entries(fields)) {
       // Create the column with alter flag
-      const column = mapTypeToKnex(table, fieldName, definition);
+      const column = mapTypeToKnex(table, fieldName, definition)
 
       // Mark this as an alteration
-      column.alter();
+      column.alter()
 
       // Apply constraints (these will be reapplied with the alter)
-      applyConstraints(column, definition);
+      applyConstraints(column, definition)
     }
-  });
+  })
 }
 
 /**
@@ -186,120 +185,120 @@ export async function alterKnexFields(knex, tableName, fields, options = {}) {
  * @param {object} [options={}] - Additional options
  * @returns {string} The migration code as a string
  */
-export function generateKnexMigration(tableName, schema, options = {}) {
-  const { autoIncrement = true, timestamps = false } = options;
-  
+export function generateKnexMigration (tableName, schema, options = {}) {
+  const { autoIncrement = true, timestamps = false } = options
+
   let migration = `exports.up = function(knex) {
-  return knex.schema.createTable('${tableName}', (table) => {\n`;
-  
+  return knex.schema.createTable('${tableName}', (table) => {\n`
+
   // Check if schema has an 'id' field with primary key
-  const hasIdField = schema.structure.id && schema.structure.id.primary === true;
-  
+  const hasIdField = schema.structure.id && schema.structure.id.primary === true
+
   // Add auto-incrementing ID if needed
   if (!hasIdField && autoIncrement) {
-    migration += `    table.increments('id').primary();\n`;
+    migration += '    table.increments(\'id\').primary();\n'
   }
-  
+
   // Process each field
   for (const [fieldName, definition] of Object.entries(schema.structure)) {
     if (fieldName === 'id' && !hasIdField && autoIncrement) {
-      continue;
+      continue
     }
-    
-    let line = '    ';
-    
+
+    let line = '    '
+
     // Map type
     switch (definition.type) {
       case 'string':
-        line += definition.maxLength 
+        line += definition.maxLength
           ? `table.string('${fieldName}', ${definition.maxLength})`
-          : `table.string('${fieldName}')`;
-        break;
+          : `table.string('${fieldName}')`
+        break
       case 'number':
         if (definition.precision !== undefined && definition.scale !== undefined) {
-          line += `table.decimal('${fieldName}', ${definition.precision}, ${definition.scale})`;
+          line += `table.decimal('${fieldName}', ${definition.precision}, ${definition.scale})`
         } else {
-          line += `table.float('${fieldName}')`;
+          line += `table.float('${fieldName}')`
         }
-        break;
+        break
       case 'id':
-        line += `table.integer('${fieldName}')`;
-        if (definition.unsigned !== false) line += '.unsigned()';
-        break;
+        line += `table.integer('${fieldName}')`
+        if (definition.unsigned !== false) line += '.unsigned()'
+        break
       case 'boolean':
-        line += `table.boolean('${fieldName}')`;
-        break;
+        line += `table.boolean('${fieldName}')`
+        break
       case 'date':
-        line += `table.date('${fieldName}')`;
-        break;
+        line += `table.date('${fieldName}')`
+        break
       case 'dateTime':
-        line += `table.datetime('${fieldName}')`;
-        break;
+        line += `table.datetime('${fieldName}')`
+        break
       case 'time':
-        line += `table.time('${fieldName}')`;
-        break;
+        line += `table.time('${fieldName}')`
+        break
       case 'timestamp':
-        line += `table.integer('${fieldName}')`;
-        break;
+        line += `table.integer('${fieldName}')`
+        break
       case 'array':
       case 'object':
       case 'serialize':
-        line += `table.json('${fieldName}')`;
-        break;
+        line += `table.json('${fieldName}')`
+        break
       case 'blob':
       case 'file':
-        line += `table.binary('${fieldName}')`;
-        break;
+        line += `table.binary('${fieldName}')`
+        break
       default:
-        line += `table.string('${fieldName}')`;
+        line += `table.string('${fieldName}')`
     }
-    
+
     // Add constraints
     if (definition.nullable === true) {
-      line += '.nullable()';
+      line += '.nullable()'
     } else if (definition.required === true || definition.nullable === false) {
-      line += '.notNullable()';
+      line += '.notNullable()'
     }
-    
+
     if (definition.defaultTo !== undefined) {
-      const defaultValue = typeof definition.defaultTo === 'string' 
-        ? `'${definition.defaultTo}'` 
-        : definition.defaultTo;
-      line += `.defaultTo(${defaultValue})`;
+      const defaultValue = typeof definition.defaultTo === 'string'
+        ? `'${definition.defaultTo}'`
+        : definition.defaultTo
+      line += `.defaultTo(${defaultValue})`
     }
-    
-    if (definition.unique === true) line += '.unique()';
-    if (definition.primary === true) line += '.primary()';
-    if (definition.index === true) line += '.index()';
-    
+
+    if (definition.unique === true) line += '.unique()'
+    if (definition.primary === true) line += '.primary()'
+    if (definition.index === true) line += '.index()'
+
     if (definition.references) {
-      const refCol = definition.references.column || 'id';
-      line += `.references('${refCol}').inTable('${definition.references.table}')`;
+      const refCol = definition.references.column || 'id'
+      line += `.references('${refCol}').inTable('${definition.references.table}')`
       if (definition.references.onDelete) {
-        line += `.onDelete('${definition.references.onDelete}')`;
+        line += `.onDelete('${definition.references.onDelete}')`
       }
       if (definition.references.onUpdate) {
-        line += `.onUpdate('${definition.references.onUpdate}')`;
+        line += `.onUpdate('${definition.references.onUpdate}')`
       }
     }
-    
+
     if (definition.comment) {
-      line += `.comment('${definition.comment}')`;
+      line += `.comment('${definition.comment}')`
     }
-    
-    migration += line + ';\n';
+
+    migration += line + ';\n'
   }
-  
+
   if (timestamps) {
-    migration += `    table.timestamps(true, true);\n`;
+    migration += '    table.timestamps(true, true);\n'
   }
-  
+
   migration += `  });
 };
 
 exports.down = function(knex) {
   return knex.schema.dropTable('${tableName}');
-};`;
-  
-  return migration;
-}
+};`
+
+  return migration
+}

package/plugins/core/lib/fractional-positioning.js

@@ -1,11 +1,11 @@
-import { requirePackage } from 'hooked-api';
+import { requirePackage } from 'hooked-api'
 
-let generateKeyBetween;
+let generateKeyBetween
 try {
-  ({ generateKeyBetween } = await import('fractional-indexing'));
+  ({ generateKeyBetween } = await import('fractional-indexing'))
 } catch (e) {
-  requirePackage('fractional-indexing', 'positioning', 
-    'Fractional indexing is required for the positioning plugin to generate sortable position keys. This is a peer dependency.');
+  requirePackage('fractional-indexing', 'positioning',
+    'Fractional indexing is required for the positioning plugin to generate sortable position keys. This is a peer dependency.')
 }
 
 /**
@@ -21,55 +21,53 @@ try {
  * @param {string} positionField - Name of the position field
  * @returns {string} New position key
  */
-export function calculatePosition(items, beforeId, idField, positionField) {
+export function calculatePosition (items, beforeId, idField, positionField) {
   // Sort items by position using simple string comparison
   // Important: fractional-indexing expects ASCII/Unicode ordering, not locale-specific
   const sorted = [...items].sort((a, b) => {
-    const posA = a[positionField] || '';
-    const posB = b[positionField] || '';
-    return posA < posB ? -1 : posA > posB ? 1 : 0;
-  });
-
+    const posA = a[positionField] || ''
+    const posB = b[positionField] || ''
+    return posA < posB ? -1 : posA > posB ? 1 : 0
+  })
 
   // If no items, start in the middle
   if (sorted.length === 0) {
-    return generateKeyBetween(null, null); // Returns 'a0'
+    return generateKeyBetween(null, null) // Returns 'a0'
   }
 
   // Position at end
   if (beforeId === null || beforeId === undefined) {
-    const lastItem = sorted[sorted.length - 1];
-    return generateKeyBetween(lastItem[positionField], null);
+    const lastItem = sorted[sorted.length - 1]
+    return generateKeyBetween(lastItem[positionField], null)
   }
 
   // Find the item to position before
-  const beforeIndex = sorted.findIndex(item => String(item[idField]) === String(beforeId));
-  
+  const beforeIndex = sorted.findIndex(item => String(item[idField]) === String(beforeId))
+
   // If beforeId not found, position at end
   if (beforeIndex === -1) {
-    const lastItem = sorted[sorted.length - 1];
-    return generateKeyBetween(lastItem[positionField], null);
+    const lastItem = sorted[sorted.length - 1]
+    return generateKeyBetween(lastItem[positionField], null)
   }
 
   // Position before the found item
-  const beforeItem = sorted[beforeIndex];
-  const prevItem = beforeIndex > 0 ? sorted[beforeIndex - 1] : null;
-  
+  const beforeItem = sorted[beforeIndex]
+  const prevItem = beforeIndex > 0 ? sorted[beforeIndex - 1] : null
+
   const result = generateKeyBetween(
     prevItem ? prevItem[positionField] : null,
     beforeItem[positionField]
-  );
+  )
 
-  
-  return result;
+  return result
 }
 
 /**
  * Initialize position for first item in a group
  * @returns {string} Initial position key
  */
-export function getInitialPosition() {
-  return generateKeyBetween(null, null); // Returns 'a0'
+export function getInitialPosition () {
+  return generateKeyBetween(null, null) // Returns 'a0'
 }
 
 /**
@@ -79,40 +77,40 @@ export function getInitialPosition() {
  * @param {number} maxLength - Maximum position string length before rebalancing
  * @returns {Array} Items with new positions (or original if no rebalance needed)
  */
-export function rebalancePositions(items, positionField, maxLength = 50) {
+export function rebalancePositions (items, positionField, maxLength = 50) {
   // Check if rebalancing is needed
-  const needsRebalance = items.some(item => 
+  const needsRebalance = items.some(item =>
     item[positionField] && item[positionField].length > maxLength
-  );
-  
+  )
+
   if (!needsRebalance) {
-    return items;
+    return items
   }
 
   // Sort by current position
   const sorted = [...items].sort((a, b) => {
-    const posA = a[positionField] || '';
-    const posB = b[positionField] || '';
-    return posA < posB ? -1 : posA > posB ? 1 : 0;
-  });
+    const posA = a[positionField] || ''
+    const posB = b[positionField] || ''
+    return posA < posB ? -1 : posA > posB ? 1 : 0
+  })
 
   // Generate evenly spaced positions
-  const rebalanced = [];
-  let prevKey = null;
-  
+  const rebalanced = []
+  let prevKey = null
+
   for (let i = 0; i < sorted.length; i++) {
     // For even spacing, we generate keys sequentially
-    const newPosition = generateKeyBetween(prevKey, null);
-    
+    const newPosition = generateKeyBetween(prevKey, null)
+
     rebalanced.push({
       ...sorted[i],
       [positionField]: newPosition
-    });
-    
-    prevKey = newPosition;
+    })
+
+    prevKey = newPosition
   }
 
-  return rebalanced;
+  return rebalanced
 }
 
 /**
@@ -120,13 +118,13 @@ export function rebalancePositions(items, positionField, maxLength = 50) {
  * @param {string} position - Position value to check
  * @returns {boolean} True if valid
  */
-export function isValidPosition(position) {
+export function isValidPosition (position) {
   if (!position || typeof position !== 'string') {
-    return false;
+    return false
   }
-  
+
   // Fractional keys should match pattern: lowercase letters and digits
-  return /^[a-z0-9]+$/i.test(position);
+  return /^[a-z0-9]+$/i.test(position)
 }
 
 /**
@@ -135,8 +133,8 @@ export function isValidPosition(position) {
  * @param {string} positionField - Name of the position field
  * @returns {Array} Items without valid positions
  */
-export function getUnpositionedItems(items, positionField) {
-  return items.filter(item => !isValidPosition(item[positionField]));
+export function getUnpositionedItems (items, positionField) {
+  return items.filter(item => !isValidPosition(item[positionField]))
 }
 
 /**
@@ -146,45 +144,45 @@ export function getUnpositionedItems(items, positionField) {
  * @param {string} orderByField - Optional field to order by initially
  * @returns {Array} Items with positions assigned
  */
-export function assignInitialPositions(items, positionField, orderByField = null) {
-  const positioned = items.filter(item => isValidPosition(item[positionField]));
-  const unpositioned = items.filter(item => !isValidPosition(item[positionField]));
-  
+export function assignInitialPositions (items, positionField, orderByField = null) {
+  const positioned = items.filter(item => isValidPosition(item[positionField]))
+  const unpositioned = items.filter(item => !isValidPosition(item[positionField]))
+
   if (unpositioned.length === 0) {
-    return items;
+    return items
   }
 
   // Sort unpositioned items if orderBy field provided
   if (orderByField) {
     unpositioned.sort((a, b) => {
-      const valA = a[orderByField];
-      const valB = b[orderByField];
-      if (valA < valB) return -1;
-      if (valA > valB) return 1;
-      return 0;
-    });
+      const valA = a[orderByField]
+      const valB = b[orderByField]
+      if (valA < valB) return -1
+      if (valA > valB) return 1
+      return 0
+    })
   }
 
   // Get the last positioned item
   const sortedPositioned = [...positioned].sort((a, b) => {
-    const posA = a[positionField] || '';
-    const posB = b[positionField] || '';
-    return posA < posB ? -1 : posA > posB ? 1 : 0;
-  });
-  const lastPositioned = sortedPositioned[sortedPositioned.length - 1];
-  
-  let lastKey = lastPositioned ? lastPositioned[positionField] : null;
-  
+    const posA = a[positionField] || ''
+    const posB = b[positionField] || ''
+    return posA < posB ? -1 : posA > posB ? 1 : 0
+  })
+  const lastPositioned = sortedPositioned[sortedPositioned.length - 1]
+
+  let lastKey = lastPositioned ? lastPositioned[positionField] : null
+
   // Assign positions to unpositioned items
   const newlyPositioned = unpositioned.map(item => {
-    const newKey = generateKeyBetween(lastKey, null);
-    lastKey = newKey;
-    
+    const newKey = generateKeyBetween(lastKey, null)
+    lastKey = newKey
+
     return {
       ...item,
       [positionField]: newKey
-    };
-  });
+    }
+  })
 
-  return [...positioned, ...newlyPositioned];
-}
+  return [...positioned, ...newlyPositioned]
+}