json-rest-api 1.0.10 → 1.0.11

package/plugins/core/lib/anyapi/schema-utils.js

@@ -0,0 +1,186 @@
+const STRING_SLOT_COUNT = 10;
+const NUMBER_SLOT_COUNT = 10;
+const BOOLEAN_SLOT_COUNT = 5;
+const DATE_SLOT_COUNT = 5;
+const JSON_SLOT_COUNT = 5;
+const BELONGS_TO_SLOT_COUNT = 5;
+
+export const SLOT_LIMITS = {
+  string: STRING_SLOT_COUNT,
+  number: NUMBER_SLOT_COUNT,
+  boolean: BOOLEAN_SLOT_COUNT,
+  date: DATE_SLOT_COUNT,
+  json: JSON_SLOT_COUNT,
+  belongsTo: BELONGS_TO_SLOT_COUNT,
+};
+
+export const DEFAULT_CANONICAL_CONFIG = {
+  scopeName: 'anyapi_records',
+  tableName: 'any_records',
+  type: 'anyapi_records',
+  tenantColumn: 'tenant_id',
+  resourceColumn: 'resource',
+  relationshipColumn: 'relationship',
+  leftIdColumn: 'left_id',
+  leftResourceColumn: 'left_resource',
+  rightIdColumn: 'right_id',
+  rightResourceColumn: 'right_resource',
+};
+
+const ensureTable = async (knex, tableName, tableBuilder) => {
+  const exists = await knex.schema.hasTable(tableName);
+  if (!exists) {
+    await knex.schema.createTable(tableName, tableBuilder);
+  }
+};
+
+const ensureIndex = async (knex, tableName, columns, indexName) => {
+  const exists = await knex.schema.hasTable(tableName);
+  if (!exists) return;
+  const hasIndex = await knex.schema.withSchema('main').hasIndex?.(tableName, indexName);
+  if (!hasIndex) {
+    await knex.schema.table(tableName, (table) => {
+      table.index(columns, indexName);
+    });
+  }
+};
+
+export const ensureAnyApiSchema = async (knex) => {
+  await ensureTable(knex, 'any_records', (table) => {
+    table.increments('id').primary();
+    table.string('tenant_id').notNullable();
+    table.string('resource').notNullable();
+
+    for (let index = 1; index <= STRING_SLOT_COUNT; index += 1) {
+      table.text(`string_${index}`);
+    }
+    for (let index = 1; index <= NUMBER_SLOT_COUNT; index += 1) {
+      table.double(`number_${index}`);
+    }
+    for (let index = 1; index <= BOOLEAN_SLOT_COUNT; index += 1) {
+      table.boolean(`boolean_${index}`);
+    }
+    for (let index = 1; index <= DATE_SLOT_COUNT; index += 1) {
+      table.dateTime(`date_${index}`);
+    }
+    for (let index = 1; index <= JSON_SLOT_COUNT; index += 1) {
+      table.text(`json_${index}`);
+    }
+
+    for (let index = 1; index <= BELONGS_TO_SLOT_COUNT; index += 1) {
+      table.string(`rel_${index}_id`);
+      table.string(`rel_${index}_type`);
+    }
+
+    table.dateTime('created_at').defaultTo(knex.fn.now()).notNullable();
+    table.dateTime('updated_at').defaultTo(knex.fn.now()).notNullable();
+    table.dateTime('deleted_at');
+
+    table.index(['tenant_id', 'resource']);
+    table.index(['resource']);
+  });
+
+  await ensureTable(knex, 'any_links', (table) => {
+    table.increments('id').primary();
+    table.string('tenant_id').notNullable();
+    table.string('relationship').notNullable();
+    table.string('inverse_relationship');
+    table.string('left_resource').notNullable();
+    table.string('left_id').notNullable();
+    table.string('right_resource').notNullable();
+    table.string('right_id').notNullable();
+    table.text('payload');
+    table.dateTime('created_at').defaultTo(knex.fn.now()).notNullable();
+    table.dateTime('updated_at').defaultTo(knex.fn.now()).notNullable();
+
+    table.index(['tenant_id', 'relationship']);
+    table.index(['tenant_id', 'inverse_relationship']);
+    table.index(['tenant_id', 'left_resource']);
+    table.index(['tenant_id', 'right_resource']);
+    table.index(['relationship']);
+    table.index(['inverse_relationship']);
+  });
+
+  await ensureTable(knex, 'any_resource_configs', (table) => {
+    table.increments('id').primary();
+    table.string('tenant_id').notNullable();
+    table.string('resource').notNullable();
+    table.text('schema_json').notNullable();
+    table.text('relationships_json').notNullable();
+    table.dateTime('created_at').defaultTo(knex.fn.now()).notNullable();
+    table.dateTime('updated_at').defaultTo(knex.fn.now()).notNullable();
+
+    table.unique(['tenant_id', 'resource']);
+  });
+
+  await ensureTable(knex, 'any_field_configs', (table) => {
+    table.increments('id').primary();
+    table.integer('resource_config_id').notNullable()
+      .references('id').inTable('any_resource_configs').onDelete('CASCADE');
+    table.string('field_name').notNullable();
+    table.string('slot_type').notNullable();
+    table.integer('slot_index').notNullable();
+    table.string('slot_column').notNullable();
+    table.boolean('nullable').defaultTo(false).notNullable();
+    table.boolean('required').defaultTo(false).notNullable();
+    table.string('target_resource');
+    table.string('alias');
+    table.text('meta_json');
+    table.dateTime('created_at').defaultTo(knex.fn.now()).notNullable();
+    table.dateTime('updated_at').defaultTo(knex.fn.now()).notNullable();
+
+    table.unique(['resource_config_id', 'field_name']);
+    table.index(['resource_config_id']);
+  });
+
+  await ensureTable(knex, 'any_relationship_configs', (table) => {
+    table.increments('id').primary();
+    table.integer('resource_config_id').notNullable()
+      .references('id').inTable('any_resource_configs').onDelete('CASCADE');
+    table.string('relationship_name').notNullable();
+    table.string('relationship_type').notNullable();
+    table.string('target_resource');
+    table.integer('slot_index');
+    table.string('id_column');
+    table.string('type_column');
+    table.string('relationship_key');
+    table.string('through');
+    table.string('foreign_key');
+    table.string('other_key');
+    table.string('alias');
+    table.text('meta_json');
+    table.dateTime('created_at').defaultTo(knex.fn.now()).notNullable();
+    table.dateTime('updated_at').defaultTo(knex.fn.now()).notNullable();
+
+    table.unique(['resource_config_id', 'relationship_name']);
+    table.index(['resource_config_id']);
+  });
+};
+
+export const SLOT_POOLS = {
+  string: Array.from({ length: STRING_SLOT_COUNT }, (_, index) => `string_${index + 1}`),
+  number: Array.from({ length: NUMBER_SLOT_COUNT }, (_, index) => `number_${index + 1}`),
+  boolean: Array.from({ length: BOOLEAN_SLOT_COUNT }, (_, index) => `boolean_${index + 1}`),
+  date: Array.from({ length: DATE_SLOT_COUNT }, (_, index) => `date_${index + 1}`),
+  json: Array.from({ length: JSON_SLOT_COUNT }, (_, index) => `json_${index + 1}`),
+  belongsTo: Array.from({ length: BELONGS_TO_SLOT_COUNT }, (_, index) => index + 1),
+};
+
+export const TYPE_TO_POOL = new Map([
+  ['string', 'string'],
+  ['text', 'string'],
+  ['uuid', 'string'],
+  ['email', 'string'],
+  ['number', 'number'],
+  ['integer', 'number'],
+  ['float', 'number'],
+  ['decimal', 'number'],
+  ['boolean', 'boolean'],
+  ['date', 'date'],
+  ['datetime', 'date'],
+  ['dateTime', 'date'],
+  ['timestamp', 'date'],
+  ['time', 'date'],
+  ['json', 'json'],
+  ['object', 'json'],
+]);

package/plugins/core/lib/anyapi/utils/descriptor-helpers.js

@@ -0,0 +1,113 @@
+import { RestApiValidationError } from '../../../../../lib/rest-api-errors.js';
+
+export const normalizeId = (value) => (value === null || value === undefined ? null : String(value));
+
+export const findSchemaFieldByAlias = (descriptor, alias) => {
+  if (!descriptor?.schema) return null;
+  for (const [fieldName, definition] of Object.entries(descriptor.schema)) {
+    if (!definition) continue;
+    if (definition.as === alias) {
+      return { fieldName, definition };
+    }
+    if (definition.belongsTo && !definition.as) {
+      const inferredAlias = fieldName.endsWith('_id') ? fieldName.slice(0, -3) : fieldName;
+      if (inferredAlias === alias) {
+        return { fieldName, definition };
+      }
+    }
+  }
+  return null;
+};
+
+export const resolveFieldInfo = (descriptor, field) => {
+  if (!descriptor) return null;
+  if (field === 'id') {
+    return { column: 'id', definition: { type: 'id' } };
+  }
+
+  const directField = descriptor.fields?.[field];
+  if (directField?.slot) {
+    return {
+      column: directField.slot,
+      definition: descriptor.schema?.[field] || null,
+    };
+  }
+
+  const belongsToInfo = descriptor.belongsTo?.[field];
+  if (belongsToInfo?.idColumn) {
+    const schemaField = findSchemaFieldByAlias(descriptor, field);
+    return {
+      column: belongsToInfo.idColumn,
+      definition: schemaField?.definition || null,
+      isRelationship: true,
+    };
+  }
+
+  const aliasField = findSchemaFieldByAlias(descriptor, field);
+  if (aliasField) {
+    const fieldEntry = descriptor.fields?.[aliasField.fieldName];
+    if (fieldEntry?.slot) {
+      return {
+        column: fieldEntry.slot,
+        definition: aliasField.definition,
+      };
+    }
+  }
+
+  return null;
+};
+
+export const coerceValueForDefinition = (value, definition, { isRelationship } = {}) => {
+  if (value === null || value === undefined) return null;
+
+  if (isRelationship) {
+    return normalizeId(value);
+  }
+
+  const type = definition?.type || definition?.dataType;
+  if (!type) {
+    return value;
+  }
+
+  if (['number', 'integer', 'float', 'decimal'].includes(type)) {
+    const numeric = Number(value);
+    return Number.isNaN(numeric) ? value : numeric;
+  }
+
+  if (type === 'boolean') {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'string') {
+      if (value.toLowerCase() === 'true') return true;
+      if (value.toLowerCase() === 'false') return false;
+    }
+    return Boolean(value);
+  }
+
+  if (['string', 'text', 'uuid', 'email'].includes(type)) {
+    return String(value);
+  }
+
+  return value;
+};
+
+export const normalizeFilterValues = (rawValue, definition, options) => {
+  if (Array.isArray(rawValue)) {
+    return rawValue.map((item) => coerceValueForDefinition(item, definition, options));
+  }
+  return [coerceValueForDefinition(rawValue, definition, options)];
+};
+
+export const ensureFilterableField = (descriptor, field) => {
+  const fieldInfo = resolveFieldInfo(descriptor, field);
+  if (!fieldInfo?.column) {
+    throw new RestApiValidationError('Invalid filter field', {
+      fields: [`filters.${field}`],
+      violations: [{
+        field: `filters.${field}`,
+        rule: 'unknown_field',
+        message: `Filter on '${field}' is not supported in AnyAPI mode`,
+      }],
+    });
+  }
+  return fieldInfo;
+};

package/plugins/core/lib/dbTablesOperations.js

@@ -0,0 +1,305 @@
+/**
+ * @file Creates Knex table definitions from json-rest-schema definitions
+ */
+
+/**
+ * Maps json-rest-schema types to Knex column types
+ * @param {object} table - The Knex table builder instance
+ * @param {string} columnName - The name of the column
+ * @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;
+  
+  switch (type) {
+    case 'string':
+      return maxLength ? table.string(columnName, maxLength) : table.string(columnName);
+    
+    case 'number':
+      if (precision !== undefined && scale !== undefined) {
+        return table.decimal(columnName, precision, scale);
+      }
+      return table.float(columnName);
+    
+    case 'id':
+      const col = table.integer(columnName);
+      return unsigned !== false ? col.unsigned() : col;
+    
+    case 'boolean':
+      return table.boolean(columnName);
+    
+    case 'date':
+      return table.date(columnName);
+    
+    case 'dateTime':
+      return table.datetime(columnName);
+    
+    case 'time':
+      return table.time(columnName);
+    
+    case 'timestamp':
+      return table.integer(columnName);
+    
+    case 'array':
+    case 'object':
+    case 'serialize':
+      return table.json(columnName);
+    
+    case 'blob':
+    case 'file':
+      return table.binary(columnName);
+    
+    case 'none':
+    default:
+      return table.string(columnName);
+  }
+}
+
+/**
+ * Applies schema constraints to a Knex column
+ * @param {object} column - The Knex column builder instance
+ * @param {object} definition - The schema definition for the field
+ */
+function applyConstraints(column, definition) {
+  // Nullability
+  if (definition.nullable === true) {
+    column.nullable();
+  } else if (definition.required === true || definition.nullable === false) {
+    column.notNullable();
+  }
+  
+  // Default value
+  if (definition.defaultTo !== undefined) {
+    column.defaultTo(definition.defaultTo);
+  }
+  
+  // Database-specific constraints
+  if (definition.unique === true) {
+    column.unique();
+  }
+  
+  if (definition.primary === true) {
+    column.primary();
+  }
+  
+  if (definition.index === true) {
+    column.index();
+  }
+  
+  if (definition.references) {
+    column.references(definition.references.column || 'id')
+      .inTable(definition.references.table);
+    
+    if (definition.references.onDelete) {
+      column.onDelete(definition.references.onDelete);
+    }
+    
+    if (definition.references.onUpdate) {
+      column.onUpdate(definition.references.onUpdate);
+    }
+  }
+  
+  if (definition.comment) {
+    column.comment(definition.comment);
+  }
+}
+
+/**
+ * Creates a Knex table from a json-rest-schema definition
+ * @param {object} knex - The Knex instance
+ * @param {string} tableName - The name of the table to create
+ * @param {object} schema - The json-rest-schema instance
+ * @param {string} [idProperty='id'] - The name of the ID column
+ * @param {object} [options={}] - Additional options
+ * @param {boolean} [options.autoIncrement=true] - Whether to use auto-incrementing IDs
+ * @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;
+  
+
+  const tableName = schemaInfo.tableName
+  const idProperty = schemaInfo.idProperty
+  const tableSchemaStructure = tableSchemaInstance.structure
+
+  return knex.schema.createTable(tableName, (table) => {
+    // Check if schema has the idProperty field with primary key
+    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();
+    }
+    
+    // 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;
+      }
+      
+      // Create the column with the appropriate type
+      const column = mapTypeToKnex(table, fieldName, definition);
+      
+      // Apply constraints
+      applyConstraints(column, definition);
+    }
+    
+    // Add timestamps if requested
+    if (timestamps) {
+      table.timestamps(true, true);
+    }
+  });
+}
+
+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);
+    }
+  });
+}
+
+// Helper function to alter multiple fields in an existing table
+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);
+
+      // Mark this as an alteration
+      column.alter();
+
+      // Apply constraints (these will be reapplied with the alter)
+      applyConstraints(column, definition);
+    }
+  });
+}
+
+/**
+ * Generates a Knex migration string from a json-rest-schema definition
+ * @param {string} tableName - The name of the table
+ * @param {object} schema - The json-rest-schema instance
+ * @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;
+  
+  let migration = `exports.up = function(knex) {
+  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;
+  
+  // Add auto-incrementing ID if needed
+  if (!hasIdField && autoIncrement) {
+    migration += `    table.increments('id').primary();\n`;
+  }
+  
+  // Process each field
+  for (const [fieldName, definition] of Object.entries(schema.structure)) {
+    if (fieldName === 'id' && !hasIdField && autoIncrement) {
+      continue;
+    }
+    
+    let line = '    ';
+    
+    // Map type
+    switch (definition.type) {
+      case 'string':
+        line += definition.maxLength 
+          ? `table.string('${fieldName}', ${definition.maxLength})`
+          : `table.string('${fieldName}')`;
+        break;
+      case 'number':
+        if (definition.precision !== undefined && definition.scale !== undefined) {
+          line += `table.decimal('${fieldName}', ${definition.precision}, ${definition.scale})`;
+        } else {
+          line += `table.float('${fieldName}')`;
+        }
+        break;
+      case 'id':
+        line += `table.integer('${fieldName}')`;
+        if (definition.unsigned !== false) line += '.unsigned()';
+        break;
+      case 'boolean':
+        line += `table.boolean('${fieldName}')`;
+        break;
+      case 'date':
+        line += `table.date('${fieldName}')`;
+        break;
+      case 'dateTime':
+        line += `table.datetime('${fieldName}')`;
+        break;
+      case 'time':
+        line += `table.time('${fieldName}')`;
+        break;
+      case 'timestamp':
+        line += `table.integer('${fieldName}')`;
+        break;
+      case 'array':
+      case 'object':
+      case 'serialize':
+        line += `table.json('${fieldName}')`;
+        break;
+      case 'blob':
+      case 'file':
+        line += `table.binary('${fieldName}')`;
+        break;
+      default:
+        line += `table.string('${fieldName}')`;
+    }
+    
+    // Add constraints
+    if (definition.nullable === true) {
+      line += '.nullable()';
+    } else if (definition.required === true || definition.nullable === false) {
+      line += '.notNullable()';
+    }
+    
+    if (definition.defaultTo !== undefined) {
+      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.references) {
+      const refCol = definition.references.column || 'id';
+      line += `.references('${refCol}').inTable('${definition.references.table}')`;
+      if (definition.references.onDelete) {
+        line += `.onDelete('${definition.references.onDelete}')`;
+      }
+      if (definition.references.onUpdate) {
+        line += `.onUpdate('${definition.references.onUpdate}')`;
+      }
+    }
+    
+    if (definition.comment) {
+      line += `.comment('${definition.comment}')`;
+    }
+    
+    migration += line + ';\n';
+  }
+  
+  if (timestamps) {
+    migration += `    table.timestamps(true, true);\n`;
+  }
+  
+  migration += `  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTable('${tableName}');
+};`;
+  
+  return migration;
+}