@basictech/schema 0.5.0 → 0.7.0-beta.0

package/index.ts

@@ -1,6 +1,7 @@
 // Basic Schema Library
 // utils for validating and interacting with Basic schemas
-import Ajv from 'ajv'
+import { validate as standaloneValidator } from './generated-validator'
+import type { ErrorObject as AjvErrorObject } from 'ajv'
 
 const basicJsonSchema = {
     "$schema": "http://json-schema.org/draft-07/schema#",
@@ -19,16 +20,16 @@ const basicJsonSchema = {
         "tables": {
             "type": "object",
             "propertyNames": {
-                "pattern": "^[a-zA-Z0-9_]+$",
+                "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$",
                 "minLength": 1,
                 "maxLength": 50, 
                 "type": "string"
             },
             "patternProperties": {
-                "^[a-zA-Z0-9_]+$": {
+                "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$": {
                     "type": "object",
                     "propertyNames": {
-                        "pattern": "^[a-zA-Z0-9_]+$",
+                        "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$",
                         "minLength": 1,
                         "maxLength": 50, 
                         "type": "string"
@@ -68,13 +69,13 @@ const basicJsonSchema = {
                         "fields": {
                             "type": "object",
                             "propertyNames": {
-                                "pattern": "^[a-zA-Z0-9_]+$",
+                                "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$",
                                 "minLength": 1,
                                 "maxLength": 50, 
                                 "type": "string"
                             },
                             "patternProperties": {
-                                "^[a-zA-Z0-9_]+$": {
+                                "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$": {
                                     "type": "object",
                                     "properties": {
                                         "type": {
@@ -103,9 +104,8 @@ const basicJsonSchema = {
     "required": ["project_id", "version", "tables"]
 }
 
-const ajv = new Ajv()
-const validator = ajv.compile(basicJsonSchema)
-
+// Using standalone pre-compiled validator (no dynamic code generation)
+const validator = standaloneValidator
 
 function generateEmptySchema(project_id: string = "", version: number = 0) {
     return {
@@ -153,12 +153,69 @@ function compareSchemas(oldSchema: any, newSchema: any) {
  * @param schema - The schema to validate
  * @returns {valid: boolean, errors: any[]} - The validation result
  */
-function validateSchema(schema: Schema): { valid: boolean, errors: ErrorObject[] } {
+function validateSchema(schema: Schema): { valid: boolean, errors: AjvErrorObject[] } {
     const v = validator(schema)
+    const ajvErrors = validator.errors || []
+    
+    // Add custom validation for case-insensitive duplicates
+    const customErrors = validateCaseInsensitiveNames(schema)
+    
     return {
-        valid: v,
-        errors: validator.errors || []
+        valid: v && customErrors.length === 0,
+        errors: [...ajvErrors, ...customErrors]
+    }
+}
+
+/**
+ * Validate that table and field names are case-insensitive unique
+ * @param schema - The schema to validate
+ * @returns Array of validation errors
+ */
+function validateCaseInsensitiveNames(schema: Schema): ErrorObject[] {
+    const errors: ErrorObject[] = []
+    
+    if (!schema.tables) return errors
+    
+    // Check for case-insensitive duplicate table names
+    const tableNames = new Set<string>()
+    for (const tableName in schema.tables) {
+        const lowerTableName = tableName.toLowerCase()
+        if (tableNames.has(lowerTableName)) {
+            errors.push({
+                keyword: 'caseInsensitiveDuplicate',
+                instancePath: `/tables/${tableName}`,
+                schemaPath: '#/properties/tables/propertyNames',
+                params: { propertyName: tableName },
+                message: `Table name "${tableName}" conflicts with another table name (case-insensitive)`
+            })
+        } else {
+            tableNames.add(lowerTableName)
+        }
+    }
+    
+    // Check for case-insensitive duplicate field names within each table
+    for (const tableName in schema.tables) {
+        const table = schema.tables[tableName]
+        if (!table.fields) continue
+        
+        const fieldNames = new Set<string>()
+        for (const fieldName in table.fields) {
+            const lowerFieldName = fieldName.toLowerCase()
+            if (fieldNames.has(lowerFieldName)) {
+                errors.push({
+                    keyword: 'caseInsensitiveDuplicate',
+                    instancePath: `/tables/${tableName}/fields/${fieldName}`,
+                    schemaPath: '#/properties/tables/patternProperties/^%5E%28%3F%21id%24%7CID%24%7CId%24%7CiD%24%29%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/propertyNames',
+                    params: { propertyName: fieldName },
+                    message: `Field name "${fieldName}" conflicts with another field name in table "${tableName}" (case-insensitive)`
+                })
+            } else {
+                fieldNames.add(lowerFieldName)
+            }
+        }
     }
+    
+    return errors
 }
 
 type ErrorObject = {
@@ -298,51 +355,53 @@ function _getSchemaChanges(oldSchema: any, newSchema: any): SchemaChange[] {
             continue
         }
 
-        // Compare fields
-        for (const fieldName in newTable.fields) {
-            const newField = newTable.fields[fieldName]
-            const oldField = oldTable.fields[fieldName]
+        // Compare fields - only if both tables have fields
+        if (newTable.fields && oldTable.fields) {
+            for (const fieldName in newTable.fields) {
+                const newField = newTable.fields[fieldName]
+                const oldField = oldTable.fields[fieldName]
 
-            if (!oldField) {
-                changes.push({
-                    type: 'field_added',
-                    table: tableName,
-                    field: fieldName
-                })
-                continue
-            }
+                if (!oldField) {
+                    changes.push({
+                        type: 'field_added',
+                        table: tableName,
+                        field: fieldName
+                    })
+                    continue
+                }
 
-            // Check for field type changes
-            if (newField.type !== oldField.type) {
-                changes.push({
-                    type: 'field_type_changed',
-                    table: tableName,
-                    field: fieldName,
-                    old: oldField.type,
-                    new: newField.type
-                })
-            }
+                // Check for field type changes
+                if (newField.type !== oldField.type) {
+                    changes.push({
+                        type: 'field_type_changed',
+                        table: tableName,
+                        field: fieldName,
+                        old: oldField.type,
+                        new: newField.type
+                    })
+                }
 
-            // Check for required flag changes
-            if (newField.required !== oldField.required) {
-                changes.push({
-                    type: 'field_required_changed',
-                    table: tableName,
-                    field: fieldName,
-                    old: oldField.required,
-                    new: newField.required
-                })
+                // Check for required flag changes
+                if (newField.required !== oldField.required) {
+                    changes.push({
+                        type: 'field_required_changed',
+                        table: tableName,
+                        field: fieldName,
+                        old: oldField.required,
+                        new: newField.required
+                    })
+                }
             }
-        }
 
-        // Check for removed fields
-        for (const fieldName in oldTable.fields) {
-            if (!newTable.fields[fieldName]) {
-                changes.push({
-                    type: 'field_removed',
-                    table: tableName,
-                    field: fieldName
-                })
+            // Check for removed fields
+            for (const fieldName in oldTable.fields) {
+                if (!newTable.fields[fieldName]) {
+                    changes.push({
+                        type: 'field_removed',
+                        table: tableName,
+                        field: fieldName
+                    })
+                }
             }
         }
     }
@@ -352,7 +411,7 @@ function _getSchemaChanges(oldSchema: any, newSchema: any): SchemaChange[] {
         const newTable = newSchema.tables[tableName]
         const oldTable = oldSchema.tables[tableName]
 
-        if (!oldTable) continue
+        if (!oldTable || !newTable.fields || !oldTable.fields) continue
 
         for (const fieldName in newTable.fields) {
             const newField = newTable.fields[fieldName]
@@ -409,9 +468,25 @@ function validateUpdateSchema(oldSchema: any, newSchema: any) {
     const newValid = validateSchema(newSchema)
 
     if (!oldValid.valid || !newValid.valid) {
-        return { valid: false, errors: oldValid.errors.concat(newValid.errors), message: "schemas are is invalid" }
+        return { valid: false, errors: oldValid.errors.concat(newValid.errors), message: "schemas are invalid" }
     }
 
+    // Always check that version is incremented by 1
+    if (newSchema.version !== oldSchema.version + 1) {
+        return {
+            valid: false,
+            errors: [{
+                change: {
+                    type: 'property_changed',
+                    property: 'version',
+                    old: oldSchema.version,
+                    new: newSchema.version
+                },
+                message: `Version must be incremented by 1. Expected version:${oldSchema.version + 1}, got version:${newSchema.version}`
+            }],
+            message: "Version must be incremented by 1"
+        }
+    }
 
     const changes = _getSchemaChanges(oldSchema, newSchema)
 
@@ -424,15 +499,6 @@ function validateUpdateSchema(oldSchema: any, newSchema: any) {
             })
         }
 
-        if (change.type === 'property_changed' && change.property === 'version') {
-            if (change.new !== change.old + 1) {
-                changeErrors.push({
-                    change: change,
-                    message: `Version must be incremented by 1. Expected version:${change.old + 1}, got version:${change.new}`
-                })
-            }
-        }
-
         if (change.type === 'field_type_changed') {
             changeErrors.push({
                 change: change,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basictech/schema",
-  "version": "0.5.0",
+  "version": "0.7.0-beta.0",
   "description": "utils for Basic Schema",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -10,19 +10,23 @@
     "access": "public"
   },
   "scripts": {
+    "prebuild": "node scripts/generate-validator.js",
     "build": "tsup",
     "dev": "tsup --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "generate-validator": "node scripts/generate-validator.js"
   },
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "ajv": "^8.17.1"
+    "ajv": "^8.17.1",
+    "ajv-errors": "^3.0.0"
   },
   "devDependencies": {
     "@repo/typescript-config": "*",
     "tsup": "^7.2.0",
-    "typescript": "^5.0.0"
-  },
-  "peerDependencies": {}
-}
+    "typescript": "^5.0.0",
+    "vitest": "^1.6.0"
+  }
+}

package/scripts/generate-validator.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+const Ajv = require('ajv')
+const standaloneCode = require('ajv/dist/standalone')
+const { writeFileSync, mkdirSync } = require('fs')
+const { dirname } = require('path')
+
+// Define the same schema as in index.ts
+const basicJsonSchema = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "project_id": {
+            "type": "string"
+        },
+        "namespace": {
+            "type": "string",
+        },
+        "version": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "tables": {
+            "type": "object",
+            "propertyNames": {
+                "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$",
+                "minLength": 1,
+                "maxLength": 50, 
+                "type": "string"
+            },
+            "patternProperties": {
+                "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$": {
+                    "type": "object",
+                    "propertyNames": {
+                        "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$",
+                        "minLength": 1,
+                        "maxLength": 50, 
+                        "type": "string"
+                    },
+                    "properties": {
+                        "name": {
+                            "type": "string"
+                        },
+                        "type": {
+                            "type": "string",
+                            "enum": ["collection"]
+                        },
+                        "origin": {
+                            "type": "object",
+                            "properties": {
+                                "type": {
+                                    "type": "string",
+                                    "enum": ["reference"]
+                                },
+                                "project_id": {
+                                    "type": "string"
+                                },
+                                "table": {
+                                    "type": "string"
+                                },
+                                "version": {
+                                    "type": "integer"
+                                }
+                            },
+                            "if": {
+                                "properties": { "type": { "const": "reference" } }
+                            },
+                            "then": {
+                                "required": ["project_id", "table"]
+                            }
+                        },
+                        "fields": {
+                            "type": "object",
+                            "propertyNames": {
+                                "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$",
+                                "minLength": 1,
+                                "maxLength": 50, 
+                                "type": "string"
+                            },
+                            "patternProperties": {
+                                "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$": {
+                                    "type": "object",
+                                    "properties": {
+                                        "type": {
+                                            "type": "string",
+                                            "enum": ["string", "boolean", "number", "json"]
+                                        },
+                                        "indexed": {
+                                            "type": "boolean"
+                                        },
+                                        "required": {
+                                            "type": "boolean"
+                                        }
+                                    },
+                                    "required": ["type"]
+                                }
+                            },
+                            "additionalProperties": true
+                        }
+                    },
+                    "required": ["fields"]
+                }
+            },
+            "additionalProperties": true
+        }
+    },
+    "required": ["project_id", "version", "tables"]
+}
+
+console.log('Generating standalone AJV validator...')
+
+// Create AJV instance with source code generation enabled
+const ajv = new Ajv({
+    code: { 
+        source: true, 
+        esm: true,
+        optimize: false  // Disable optimizations that might require runtime deps
+    },
+    allErrors: true,
+    strict: false,  // Be more lenient to avoid runtime dependencies
+    validateFormats: false,  // Disable format validation to avoid dependencies
+    addUsedSchema: false  // Don't add used schemas to avoid dependencies
+})
+
+// Compile the schema
+const validate = ajv.compile(basicJsonSchema)
+
+// Generate standalone code
+let moduleCode = standaloneCode(ajv, validate)
+
+// Post-process to remove runtime dependencies
+// Replace the ucs2length require with a native implementation
+const ucs2LengthFunc = `
+// Modern JavaScript Unicode string length (replaces ajv/dist/runtime/ucs2length)
+const ucs2length = (str) => [...str].length;
+`
+
+// Replace the require statement with our function
+moduleCode = moduleCode.replace(
+  /const func2 = require\("ajv\/dist\/runtime\/ucs2length"\)\.default;/g,
+  ucs2LengthFunc + 'const func2 = ucs2length;'
+)
+
+// Ensure the directory exists
+const outputPath = 'generated-validator.js'
+const typesPath = 'generated-validator.d.ts'
+
+// Write the generated validator
+writeFileSync(outputPath, moduleCode)
+
+// Create TypeScript declaration file
+const typeDeclaration = `export declare const validate: {
+  (data: any, options?: any): boolean;
+  errors?: any[] | null;
+};
+export default validate;
+`
+writeFileSync(typesPath, typeDeclaration)
+
+console.log(`✅ Standalone validator generated at ${outputPath}`)

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+  },
+})