@stonecrop/utilities 0.11.0 → 0.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stonecrop/utilities",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "license": "MIT",
   "type": "module",
   "author": {

package/dist/naming-conventions.js

@@ -1,135 +0,0 @@
-/**
- * Naming Convention Utilities
- * Converts between SQL snake_case and JavaScript camelCase naming conventions
- * @packageDocumentation
- */
-/**
- * Converts snake_case to camelCase
- * @param snakeCase - Snake case string
- * @returns Camel case string
- * @public
- * @example
- * ```typescript
- * snakeToCamel('user_email') // 'userEmail'
- * snakeToCamel('created_at') // 'createdAt'
- * snakeToCamel('user_id') // 'userId'
- * ```
- */
-export function snakeToCamel(snakeCase) {
-    return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-/**
- * Converts camelCase to snake_case
- * @param camelCase - Camel case string
- * @returns Snake case string
- * @public
- * @example
- * ```typescript
- * camelToSnake('userEmail') // 'user_email'
- * camelToSnake('createdAt') // 'created_at'
- * camelToSnake('userId') // 'user_id'
- * ```
- */
-export function camelToSnake(camelCase) {
-    return camelCase.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-}
-/**
- * Converts snake_case to Title Case label
- * @param snakeCase - Snake case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * snakeToLabel('user_email') // 'User Email'
- * snakeToLabel('first_name') // 'First Name'
- * snakeToLabel('created_at') // 'Created At'
- * ```
- */
-export function snakeToLabel(snakeCase) {
-    return snakeCase
-        .split('_')
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join(' ');
-}
-/**
- * Converts camelCase to Title Case label
- * @param camelCase - Camel case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * camelToLabel('userEmail') // 'User Email'
- * camelToLabel('firstName') // 'First Name'
- * camelToLabel('createdAt') // 'Created At'
- * ```
- */
-export function camelToLabel(camelCase) {
-    // Insert space before capital letters and capitalize first letter
-    const withSpaces = camelCase.replace(/([A-Z])/g, ' $1').trim();
-    return withSpaces.charAt(0).toUpperCase() + withSpaces.slice(1);
-}
-/**
- * Converts SQL column name to Stonecrop field naming convention
- * Handles special cases like ID suffixes
- * @param sqlName - SQL column name (snake_case)
- * @returns Field name and label
- * @public
- * @example
- * ```typescript
- * convertSQLName('user_email')
- * // { fieldname: 'userEmail', label: 'User Email', originalName: 'user_email' }
- *
- * convertSQLName('user_id')
- * // { fieldname: 'userId', label: 'User', originalName: 'user_id' }
- *
- * convertSQLName('created_at')
- * // { fieldname: 'createdAt', label: 'Created At', originalName: 'created_at' }
- * ```
- */
-export function convertSQLName(sqlName) {
-    const fieldname = snakeToCamel(sqlName);
-    // Generate label - special handling for _id suffix
-    let label;
-    if (sqlName.endsWith('_id')) {
-        // Remove _id suffix for label: user_id -> User
-        const withoutId = sqlName.slice(0, -3);
-        label = snakeToLabel(withoutId);
-    }
-    else {
-        label = snakeToLabel(sqlName);
-    }
-    return {
-        fieldname,
-        label,
-        originalName: sqlName,
-    };
-}
-/**
- * Batch converts multiple SQL column names
- * @param sqlNames - Array of SQL column names
- * @returns Array of name conversions
- * @public
- */
-export function convertSQLNames(sqlNames) {
-    return sqlNames.map(convertSQLName);
-}
-/**
- * Creates a bidirectional mapping between SQL and Stonecrop names
- * @param sqlNames - Array of SQL column names
- * @returns Mapping object with both directions
- * @public
- */
-export function createNameMapping(sqlNames) {
-    const conversions = convertSQLNames(sqlNames);
-    const sqlToFieldname = new Map();
-    const fieldnameToSQL = new Map();
-    for (const conversion of conversions) {
-        sqlToFieldname.set(conversion.originalName, conversion.fieldname);
-        fieldnameToSQL.set(conversion.fieldname, conversion.originalName);
-    }
-    return {
-        sqlToFieldname,
-        fieldnameToSQL,
-        conversions,
-    };
-}

package/dist/sql-introspection.js

@@ -1,260 +0,0 @@
-/**
- * SQL Schema Introspection Utilities
- * Parses PostgreSQL DDL and converts to Stonecrop schema format
- * @packageDocumentation
- */
-/**
- * Maps PostgreSQL data types to Stonecrop field types
- * @param sqlType - PostgreSQL data type
- * @param enumValues - Enum values if type is ENUM
- * @returns Corresponding Stonecrop field type
- * @public
- */
-export function mapSQLTypeToFieldType(sqlType, enumValues) {
-    const normalizedType = sqlType.toLowerCase().trim();
-    // Handle parameterized types (e.g., varchar(255) -> varchar)
-    const baseType = normalizedType.split('(')[0].trim();
-    // Enum types become Select fields
-    if (enumValues && enumValues.length > 0) {
-        return 'Select';
-    }
-    // Type mapping based on PostgreSQL types
-    const typeMap = {
-        // Text types
-        varchar: 'Data',
-        character: 'Data',
-        char: 'Data',
-        text: 'Text',
-        // Numeric types
-        integer: 'Int',
-        int: 'Int',
-        int2: 'Int',
-        int4: 'Int',
-        int8: 'Int',
-        smallint: 'Int',
-        bigint: 'Int',
-        serial: 'Int',
-        bigserial: 'Int',
-        // Float types
-        numeric: 'Float',
-        decimal: 'Float',
-        real: 'Float',
-        float: 'Float',
-        float4: 'Float',
-        float8: 'Float',
-        double: 'Float',
-        money: 'Currency',
-        // Boolean
-        boolean: 'Check',
-        bool: 'Check',
-        // Date/Time types
-        timestamp: 'Datetime',
-        timestamptz: 'Datetime',
-        date: 'Date',
-        time: 'Time',
-        timetz: 'Time',
-        // JSON types (use Code for now)
-        json: 'Code',
-        jsonb: 'Code',
-        xml: 'Code',
-        // Array types (use Text for serialization)
-        array: 'Text',
-    };
-    return typeMap[baseType] || 'Data';
-}
-/**
- * Parses a PostgreSQL CREATE TABLE statement
- * @param ddl - SQL DDL string
- * @returns Array of parsed tables
- * @public
- */
-export function parseDDL(ddl) {
-    const tables = [];
-    // Split by CREATE TABLE statements
-    const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:(\w+)\.)?(\w+)\s*\(([\s\S]*?)\);/gi;
-    let match;
-    while ((match = createTableRegex.exec(ddl)) !== null) {
-        const schema = match[1];
-        const tableName = match[2];
-        const columnsDef = match[3];
-        const table = {
-            name: tableName,
-            columns: [],
-            schema: schema || 'public',
-        };
-        // Parse columns and constraints
-        const lines = columnsDef.split(',').map(l => l.trim());
-        const primaryKeys = [];
-        const foreignKeys = new Map();
-        const uniqueColumns = new Set();
-        for (const line of lines) {
-            // Skip empty lines
-            if (!line)
-                continue;
-            // Handle PRIMARY KEY constraint
-            if (/PRIMARY\s+KEY/i.test(line)) {
-                const pkMatch = line.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
-                if (pkMatch) {
-                    const cols = pkMatch[1].split(',').map(c => c.trim().replace(/"/g, ''));
-                    primaryKeys.push(...cols);
-                }
-                continue;
-            }
-            // Handle FOREIGN KEY constraint
-            if (/FOREIGN\s+KEY/i.test(line)) {
-                const fkMatch = line.match(/FOREIGN\s+KEY\s*\(([^)]+)\)\s*REFERENCES\s+(\w+)\s*\(([^)]+)\)/i);
-                if (fkMatch) {
-                    const localCol = fkMatch[1].trim().replace(/"/g, '');
-                    const refTable = fkMatch[2].trim();
-                    const refCol = fkMatch[3].trim().replace(/"/g, '');
-                    foreignKeys.set(localCol, { table: refTable, column: refCol });
-                }
-                continue;
-            }
-            // Handle UNIQUE constraint
-            if (/UNIQUE/i.test(line) && /UNIQUE\s*\(/i.test(line)) {
-                const uniqueMatch = line.match(/UNIQUE\s*\(([^)]+)\)/i);
-                if (uniqueMatch) {
-                    const cols = uniqueMatch[1].split(',').map(c => c.trim().replace(/"/g, ''));
-                    cols.forEach(c => uniqueColumns.add(c));
-                }
-                continue;
-            }
-            // Parse column definition
-            const columnMatch = line.match(/^(\w+)\s+([A-Za-z0-9_()]+)(.*)$/i);
-            if (columnMatch) {
-                const columnName = columnMatch[1];
-                const dataType = columnMatch[2];
-                const modifiers = columnMatch[3] || '';
-                const column = {
-                    name: columnName,
-                    sqlType: dataType,
-                    notNull: /NOT\s+NULL/i.test(modifiers),
-                    primaryKey: false,
-                    unique: /UNIQUE/i.test(modifiers),
-                };
-                // Extract enum values
-                if (/^ENUM/i.test(dataType)) {
-                    const enumMatch = dataType.match(/ENUM\s*\(([^)]+)\)/i);
-                    if (enumMatch) {
-                        column.enumValues = enumMatch[1].split(',').map(v => v.trim().replace(/^'|'$/g, ''));
-                    }
-                }
-                // Extract default value
-                const defaultMatch = modifiers.match(/DEFAULT\s+([^,\s]+)/i);
-                if (defaultMatch) {
-                    column.defaultValue = defaultMatch[1];
-                }
-                // Extract CHECK constraint
-                const checkMatch = modifiers.match(/CHECK\s*\(([^)]+)\)/i);
-                if (checkMatch) {
-                    column.checkConstraint = checkMatch[1];
-                }
-                // Check for inline REFERENCES (foreign key)
-                const refMatch = modifiers.match(/REFERENCES\s+(\w+)\s*\(([^)]+)\)/i);
-                if (refMatch) {
-                    column.foreignKey = {
-                        table: refMatch[1],
-                        column: refMatch[2].trim().replace(/"/g, ''),
-                    };
-                }
-                table.columns.push(column);
-            }
-        }
-        // Apply primary keys
-        primaryKeys.forEach(pk => {
-            const col = table.columns.find(c => c.name === pk);
-            if (col) {
-                col.primaryKey = true;
-                col.notNull = true; // PKs are always NOT NULL
-            }
-        });
-        // Apply foreign keys
-        foreignKeys.forEach((fk, colName) => {
-            const col = table.columns.find(c => c.name === colName);
-            if (col) {
-                col.foreignKey = fk;
-            }
-        });
-        // Apply unique constraints
-        uniqueColumns.forEach(colName => {
-            const col = table.columns.find(c => c.name === colName);
-            if (col) {
-                col.unique = true;
-            }
-        });
-        tables.push(table);
-    }
-    return tables;
-}
-/**
- * Converts SQL table to Stonecrop schema format
- * @param table - Parsed SQL table
- * @param namingConverter - Function to convert field names
- * @returns Conversion result with schema and relationships
- * @public
- */
-export function convertTableToSchema(table, namingConverter) {
-    const result = {
-        doctype: table.name,
-        schema: [],
-        relationships: [],
-    };
-    for (const column of table.columns) {
-        const { fieldname, label } = namingConverter
-            ? namingConverter(column.name)
-            : { fieldname: column.name, label: column.name };
-        const fieldtype = column.foreignKey ? 'Link' : mapSQLTypeToFieldType(column.sqlType, column.enumValues);
-        const field = {
-            fieldname,
-            label,
-            fieldtype,
-        };
-        // Add required flag for NOT NULL columns (except PKs which are readonly)
-        if (column.notNull && !column.primaryKey) {
-            field.required = true;
-        }
-        // Make primary keys readonly
-        if (column.primaryKey) {
-            field.readonly = true;
-        }
-        // Handle foreign keys (Link fields)
-        if (column.foreignKey) {
-            field.options = column.foreignKey.table;
-            result.relationships.push({
-                fieldname,
-                targetDoctype: column.foreignKey.table,
-                targetField: column.foreignKey.column,
-            });
-        }
-        // Handle enum values (Select fields)
-        if (column.enumValues && column.enumValues.length > 0) {
-            field.options = column.enumValues.join('\n');
-        }
-        // Handle default values
-        if (column.defaultValue) {
-            // Clean up default value (remove quotes, casts, etc.)
-            let defaultVal = column.defaultValue.replace(/^'|'$/g, '');
-            if (fieldtype === 'Int' || fieldtype === 'Float') {
-                defaultVal = parseFloat(defaultVal);
-            }
-            else if (fieldtype === 'Check') {
-                defaultVal = defaultVal === 'true' || defaultVal === 't';
-            }
-            field.default = defaultVal;
-        }
-        result.schema.push(field);
-    }
-    return result;
-}
-/**
- * Introspects SQL DDL and converts all tables to Stonecrop schemas
- * @param ddl - PostgreSQL DDL string
- * @param namingConverter - Optional function to convert field names
- * @returns Array of conversion results
- * @public
- */
-export function introspectSQL(ddl, namingConverter) {
-    const tables = parseDDL(ddl);
-    return tables.map(table => convertTableToSchema(table, namingConverter));
-}