driftdetect-core 0.4.1 → 0.4.2

package/dist/call-graph/extractors/php-data-access-extractor.d.ts

@@ -0,0 +1,93 @@
+/**
+ * PHP Semantic Data Access Extractor
+ *
+ * Extracts data access points from PHP using tree-sitter.
+ * Provides accurate, semantic-aware detection of database operations.
+ *
+ * Supports:
+ * - Laravel Eloquent: User::where()->get(), $user->save()
+ * - Laravel Query Builder: DB::table('users')->get()
+ * - Doctrine ORM: $em->getRepository()->find()
+ * - PDO: $pdo->query("SELECT...")
+ * - Raw SQL: DB::select("SELECT...")
+ */
+import { BaseDataAccessExtractor, type DataAccessExtractionResult } from './data-access-extractor.js';
+import type { CallGraphLanguage } from '../types.js';
+/**
+ * PHP data access extractor using tree-sitter
+ */
+export declare class PhpDataAccessExtractor extends BaseDataAccessExtractor {
+    readonly language: CallGraphLanguage;
+    readonly extensions: string[];
+    private parser;
+    /**
+     * Check if tree-sitter is available for PHP
+     */
+    static isAvailable(): boolean;
+    /**
+     * Extract data access points from PHP source
+     */
+    extract(source: string, filePath: string): DataAccessExtractionResult;
+    /**
+     * Visit AST nodes to find data access patterns
+     */
+    private visitNode;
+    /**
+     * Analyze a member call expression (->method())
+     */
+    private analyzeMemberCall;
+    /**
+     * Analyze a static call expression (Class::method())
+     */
+    private analyzeStaticCall;
+    /**
+     * Get the call chain from a member call expression
+     */
+    private getCallChain;
+    /**
+     * Get the call chain from a static call expression
+     */
+    private getStaticCallChain;
+    /**
+     * Try to match Laravel Eloquent static pattern
+     * e.g., User::where('active', true)->get(), User::find(1)
+     */
+    private tryEloquentStaticPattern;
+    /**
+     * Extract field name from a where clause method call
+     */
+    private extractWhereClauseField;
+    /**
+     * Try to match Laravel DB facade pattern
+     * e.g., DB::table('users')->get(), DB::select("SELECT...")
+     */
+    private tryLaravelDbPattern;
+    /**
+     * Try to match Eloquent instance pattern
+     * e.g., $user->save(), $user->delete()
+     */
+    private tryEloquentInstancePattern;
+    /**
+     * Try to match Doctrine ORM pattern
+     * e.g., $em->getRepository(User::class)->find(1)
+     */
+    private tryDoctrinePattern;
+    /**
+     * Try to match PDO pattern
+     * e.g., $pdo->query("SELECT..."), $stmt->execute()
+     */
+    private tryPdoPattern;
+    /**
+     * Extract string value from a node
+     */
+    private extractStringValue;
+    /**
+     * Parse a SQL statement to extract table, operation, and fields
+     */
+    private parseSQLStatement;
+}
+/**
+ * Create a PHP data access extractor
+ */
+export declare function createPhpDataAccessExtractor(): PhpDataAccessExtractor;
+//# sourceMappingURL=php-data-access-extractor.d.ts.map

package/dist/call-graph/extractors/php-data-access-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"php-data-access-extractor.d.ts","sourceRoot":"","sources":["../../../src/call-graph/extractors/php-data-access-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,uBAAuB,EAAE,KAAK,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AACtG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAQrD;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,uBAAuB;IACjE,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAS;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAY;IAEzC,OAAO,CAAC,MAAM,CAAiC;IAE/C;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,OAAO;IAI7B;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,0BAA0B;IAwBrE;;OAEG;IACH,OAAO,CAAC,SAAS;IAsBjB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoBzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAgDpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA2D1B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA0FhC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAmB/B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAwG3B;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAyClC;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAgD1B;;;OAGG;IACH,OAAO,CAAC,aAAa;IAwDrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAqB1B;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,sBAAsB,CAErE"}

package/dist/call-graph/extractors/php-data-access-extractor.js

@@ -0,0 +1,589 @@
+/**
+ * PHP Semantic Data Access Extractor
+ *
+ * Extracts data access points from PHP using tree-sitter.
+ * Provides accurate, semantic-aware detection of database operations.
+ *
+ * Supports:
+ * - Laravel Eloquent: User::where()->get(), $user->save()
+ * - Laravel Query Builder: DB::table('users')->get()
+ * - Doctrine ORM: $em->getRepository()->find()
+ * - PDO: $pdo->query("SELECT...")
+ * - Raw SQL: DB::select("SELECT...")
+ */
+import { BaseDataAccessExtractor } from './data-access-extractor.js';
+import { isPhpTreeSitterAvailable, createPhpParser, } from '../../parsers/tree-sitter/php-loader.js';
+/**
+ * PHP data access extractor using tree-sitter
+ */
+export class PhpDataAccessExtractor extends BaseDataAccessExtractor {
+    language = 'php';
+    extensions = ['.php'];
+    parser = null;
+    /**
+     * Check if tree-sitter is available for PHP
+     */
+    static isAvailable() {
+        return isPhpTreeSitterAvailable();
+    }
+    /**
+     * Extract data access points from PHP source
+     */
+    extract(source, filePath) {
+        const result = this.createEmptyResult(filePath);
+        if (!isPhpTreeSitterAvailable()) {
+            result.errors.push('Tree-sitter not available for PHP parsing');
+            return result;
+        }
+        try {
+            if (!this.parser) {
+                this.parser = createPhpParser();
+            }
+            const tree = this.parser.parse(source);
+            this.visitNode(tree.rootNode, result, filePath, source);
+        }
+        catch (error) {
+            result.errors.push(error instanceof Error ? error.message : 'Unknown parse error');
+        }
+        return result;
+    }
+    /**
+     * Visit AST nodes to find data access patterns
+     */
+    visitNode(node, result, filePath, source) {
+        // Check for method calls (->method())
+        if (node.type === 'member_call_expression') {
+            this.analyzeMemberCall(node, result, filePath, source);
+        }
+        // Check for static method calls (Class::method())
+        if (node.type === 'scoped_call_expression') {
+            this.analyzeStaticCall(node, result, filePath, source);
+        }
+        // Recurse into children
+        for (const child of node.children) {
+            this.visitNode(child, result, filePath, source);
+        }
+    }
+    /**
+     * Analyze a member call expression (->method())
+     */
+    analyzeMemberCall(node, result, filePath, _source) {
+        const chain = this.getCallChain(node);
+        const accessPoint = this.tryEloquentInstancePattern(chain, node, filePath) ||
+            this.tryDoctrinePattern(chain, node, filePath) ||
+            this.tryPdoPattern(chain, node, filePath);
+        if (accessPoint) {
+            const exists = result.accessPoints.some(ap => ap.id === accessPoint.id);
+            if (!exists) {
+                result.accessPoints.push(accessPoint);
+            }
+        }
+    }
+    /**
+     * Analyze a static call expression (Class::method())
+     */
+    analyzeStaticCall(node, result, filePath, _source) {
+        const chain = this.getStaticCallChain(node);
+        const accessPoint = this.tryEloquentStaticPattern(chain, node, filePath) ||
+            this.tryLaravelDbPattern(chain, node, filePath);
+        if (accessPoint) {
+            const exists = result.accessPoints.some(ap => ap.id === accessPoint.id);
+            if (!exists) {
+                result.accessPoints.push(accessPoint);
+            }
+        }
+    }
+    /**
+     * Get the call chain from a member call expression
+     */
+    getCallChain(node) {
+        const names = [];
+        const args = [];
+        let current = node;
+        while (current) {
+            if (current.type === 'member_call_expression') {
+                const nameNode = current.childForFieldName('name');
+                if (nameNode) {
+                    names.unshift(nameNode.text);
+                }
+                const argsNode = current.childForFieldName('arguments');
+                if (argsNode) {
+                    const argList = [];
+                    for (const child of argsNode.children) {
+                        if (child.type !== '(' && child.type !== ')' && child.type !== ',' && child.type !== 'argument') {
+                            argList.push(child);
+                        }
+                        else if (child.type === 'argument') {
+                            argList.push(child);
+                        }
+                    }
+                    args.unshift(argList);
+                }
+                else {
+                    args.unshift([]);
+                }
+                current = current.childForFieldName('object');
+            }
+            else if (current.type === 'member_access_expression') {
+                const nameNode = current.childForFieldName('name');
+                if (nameNode) {
+                    names.unshift(nameNode.text);
+                    args.unshift([]);
+                }
+                current = current.childForFieldName('object');
+            }
+            else if (current.type === 'variable_name' || current.type === 'name') {
+                names.unshift(current.text.replace(/^\$/, ''));
+                args.unshift([]);
+                break;
+            }
+            else {
+                break;
+            }
+        }
+        return { names, args };
+    }
+    /**
+     * Get the call chain from a static call expression
+     */
+    getStaticCallChain(node) {
+        const names = [];
+        const args = [];
+        let className = '';
+        // Get the class name
+        const scopeNode = node.childForFieldName('scope');
+        if (scopeNode) {
+            className = scopeNode.text;
+        }
+        // Get the method name
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+            names.push(nameNode.text);
+        }
+        // Get arguments
+        const argsNode = node.childForFieldName('arguments');
+        if (argsNode) {
+            const argList = [];
+            for (const child of argsNode.children) {
+                if (child.type !== '(' && child.type !== ')' && child.type !== ',') {
+                    argList.push(child);
+                }
+            }
+            args.push(argList);
+        }
+        else {
+            args.push([]);
+        }
+        // Check if there's a chained call
+        let parent = node.parent;
+        while (parent) {
+            if (parent.type === 'member_call_expression') {
+                const chainNameNode = parent.childForFieldName('name');
+                if (chainNameNode) {
+                    names.push(chainNameNode.text);
+                }
+                const chainArgsNode = parent.childForFieldName('arguments');
+                if (chainArgsNode) {
+                    const argList = [];
+                    for (const child of chainArgsNode.children) {
+                        if (child.type !== '(' && child.type !== ')' && child.type !== ',') {
+                            argList.push(child);
+                        }
+                    }
+                    args.push(argList);
+                }
+                else {
+                    args.push([]);
+                }
+            }
+            parent = parent.parent;
+        }
+        return { className, names, args };
+    }
+    /**
+     * Try to match Laravel Eloquent static pattern
+     * e.g., User::where('active', true)->get(), User::find(1)
+     */
+    tryEloquentStaticPattern(chain, node, filePath) {
+        const { className, names, args } = chain;
+        if (!className || names.length === 0)
+            return null;
+        // Skip if it's DB:: (handled separately)
+        if (className === 'DB')
+            return null;
+        // Check if it looks like a model (PascalCase, not a framework class)
+        if (!/^[A-Z]/.test(className))
+            return null;
+        const frameworkClasses = ['App', 'Auth', 'Cache', 'Config', 'Cookie', 'Crypt',
+            'Event', 'File', 'Gate', 'Hash', 'Http', 'Lang',
+            'Log', 'Mail', 'Notification', 'Queue', 'Redirect',
+            'Request', 'Response', 'Route', 'Schema', 'Session',
+            'Storage', 'URL', 'Validator', 'View'];
+        if (frameworkClasses.includes(className))
+            return null;
+        const eloquentMethods = {
+            read: ['find', 'findOrFail', 'findMany', 'findOrNew', 'first', 'firstOrFail',
+                'firstOrNew', 'firstOrCreate', 'firstWhere', 'get', 'all', 'pluck',
+                'value', 'count', 'max', 'min', 'avg', 'sum', 'exists', 'doesntExist',
+                'where', 'whereIn', 'whereNotIn', 'whereBetween', 'whereNull',
+                'whereNotNull', 'whereDate', 'whereMonth', 'whereDay', 'whereYear',
+                'whereTime', 'whereColumn', 'orWhere', 'orderBy', 'latest', 'oldest',
+                'take', 'limit', 'skip', 'offset', 'with', 'withCount', 'has', 'whereHas'],
+            write: ['create', 'insert', 'insertOrIgnore', 'insertGetId', 'update',
+                'updateOrCreate', 'updateOrInsert', 'upsert', 'increment', 'decrement'],
+            delete: ['delete', 'destroy', 'forceDelete', 'truncate'],
+        };
+        // Where clause methods that take field as first argument
+        const whereClauseMethods = ['where', 'whereIn', 'whereNotIn', 'whereBetween',
+            'whereNull', 'whereNotNull', 'whereDate', 'whereMonth',
+            'whereDay', 'whereYear', 'whereTime', 'whereColumn',
+            'orWhere', 'firstWhere', 'whereHas'];
+        let operation = null;
+        const whereFields = [];
+        const firstMethod = names[0];
+        // Check all methods in chain for operation type and extract where fields
+        for (let i = 0; i < names.length; i++) {
+            const method = names[i];
+            const methodArgs = args[i];
+            if (!method)
+                continue;
+            if (eloquentMethods.write.includes(method)) {
+                operation = 'write';
+                break;
+            }
+            if (eloquentMethods.delete.includes(method)) {
+                operation = 'delete';
+                break;
+            }
+            // Extract fields from where clause methods
+            if (whereClauseMethods.includes(method) && methodArgs && methodArgs.length > 0) {
+                const fieldName = this.extractWhereClauseField(methodArgs);
+                if (fieldName) {
+                    whereFields.push(fieldName);
+                }
+            }
+        }
+        // Default to read if we have query methods
+        if (!operation && firstMethod) {
+            if (eloquentMethods.read.includes(firstMethod)) {
+                operation = 'read';
+            }
+        }
+        if (!operation)
+            return null;
+        return this.createAccessPoint({
+            table: this.inferTableFromName(className),
+            fields: [...new Set(whereFields)],
+            operation,
+            file: filePath,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            context: node.text.slice(0, 200),
+            confidence: 0.95,
+        });
+    }
+    /**
+     * Extract field name from a where clause method call
+     */
+    extractWhereClauseField(args) {
+        if (args.length === 0)
+            return null;
+        const firstArg = args[0];
+        if (!firstArg)
+            return null;
+        // Handle argument wrapper
+        const actualArg = firstArg.type === 'argument' ? firstArg.namedChildren[0] : firstArg;
+        if (!actualArg)
+            return null;
+        // String argument: ->where('email', value)
+        const strValue = this.extractStringValue(actualArg);
+        if (strValue) {
+            return strValue;
+        }
+        return null;
+    }
+    /**
+     * Try to match Laravel DB facade pattern
+     * e.g., DB::table('users')->get(), DB::select("SELECT...")
+     */
+    tryLaravelDbPattern(chain, node, filePath) {
+        const { className, names, args } = chain;
+        if (className !== 'DB')
+            return null;
+        if (names.length === 0)
+            return null;
+        const firstMethod = names[0];
+        const firstArgs = args[0];
+        // DB::table('users') pattern
+        if (firstMethod === 'table' && firstArgs && firstArgs.length > 0 && firstArgs[0]) {
+            const tableArg = firstArgs[0];
+            const table = this.extractStringValue(tableArg);
+            if (!table)
+                return null;
+            // Where clause methods
+            const whereClauseMethods = ['where', 'whereIn', 'whereNotIn', 'whereBetween',
+                'whereNull', 'whereNotNull', 'orWhere'];
+            // Determine operation from chained methods and extract where fields
+            let operation = 'read';
+            const whereFields = [];
+            for (let i = 1; i < names.length; i++) {
+                const method = names[i];
+                const methodArgs = args[i];
+                if (!method)
+                    continue;
+                if (['insert', 'insertOrIgnore', 'insertGetId', 'update', 'upsert',
+                    'increment', 'decrement'].includes(method)) {
+                    operation = 'write';
+                    break;
+                }
+                if (['delete', 'truncate'].includes(method)) {
+                    operation = 'delete';
+                    break;
+                }
+                // Extract fields from where clause methods
+                if (whereClauseMethods.includes(method) && methodArgs && methodArgs.length > 0) {
+                    const fieldName = this.extractWhereClauseField(methodArgs);
+                    if (fieldName) {
+                        whereFields.push(fieldName);
+                    }
+                }
+            }
+            return this.createAccessPoint({
+                table,
+                fields: [...new Set(whereFields)],
+                operation,
+                file: filePath,
+                line: node.startPosition.row + 1,
+                column: node.startPosition.column,
+                context: node.text.slice(0, 200),
+                confidence: 0.95,
+            });
+        }
+        // DB::select(), DB::insert(), DB::update(), DB::delete() with raw SQL
+        const rawMethods = {
+            read: ['select', 'selectOne'],
+            write: ['insert', 'update', 'statement'],
+            delete: ['delete'],
+        };
+        let operation = null;
+        if (rawMethods.read.includes(firstMethod ?? ''))
+            operation = 'read';
+        else if (rawMethods.write.includes(firstMethod ?? ''))
+            operation = 'write';
+        else if (rawMethods.delete.includes(firstMethod ?? ''))
+            operation = 'delete';
+        if (!operation)
+            return null;
+        // Try to extract table from SQL
+        let table = 'unknown';
+        if (firstArgs && firstArgs.length > 0 && firstArgs[0]) {
+            const sqlArg = firstArgs[0];
+            const sqlText = this.extractStringValue(sqlArg);
+            if (sqlText) {
+                const parsed = this.parseSQLStatement(sqlText);
+                table = parsed.table;
+            }
+        }
+        return this.createAccessPoint({
+            table,
+            fields: [],
+            operation,
+            file: filePath,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            context: node.text.slice(0, 200),
+            isRawSql: true,
+            confidence: 0.85,
+        });
+    }
+    /**
+     * Try to match Eloquent instance pattern
+     * e.g., $user->save(), $user->delete()
+     */
+    tryEloquentInstancePattern(chain, node, filePath) {
+        if (chain.names.length < 2)
+            return null;
+        const methodName = chain.names[chain.names.length - 1];
+        if (!methodName)
+            return null;
+        const instanceMethods = {
+            write: ['save', 'update', 'push', 'touch', 'increment', 'decrement',
+                'fill', 'forceFill', 'refresh', 'replicate'],
+            delete: ['delete', 'forceDelete', 'destroy'],
+        };
+        let operation = null;
+        if (instanceMethods.write.includes(methodName)) {
+            operation = 'write';
+        }
+        else if (instanceMethods.delete.includes(methodName)) {
+            operation = 'delete';
+        }
+        if (!operation)
+            return null;
+        // Try to infer model from variable name
+        const varName = chain.names[0] ?? 'unknown';
+        const table = this.inferTableFromName(varName);
+        return this.createAccessPoint({
+            table,
+            fields: [],
+            operation,
+            file: filePath,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            context: node.text.slice(0, 200),
+            confidence: 0.8,
+        });
+    }
+    /**
+     * Try to match Doctrine ORM pattern
+     * e.g., $em->getRepository(User::class)->find(1)
+     */
+    tryDoctrinePattern(chain, node, filePath) {
+        // Look for EntityManager patterns
+        const hasGetRepository = chain.names.includes('getRepository');
+        const hasFind = chain.names.includes('find') || chain.names.includes('findOneBy') ||
+            chain.names.includes('findBy') || chain.names.includes('findAll');
+        const hasPersist = chain.names.includes('persist');
+        const hasRemove = chain.names.includes('remove');
+        const hasFlush = chain.names.includes('flush');
+        if (!hasGetRepository && !hasPersist && !hasRemove)
+            return null;
+        let operation = 'read';
+        if (hasPersist || hasFlush)
+            operation = 'write';
+        if (hasRemove)
+            operation = 'delete';
+        if (hasFind)
+            operation = 'read';
+        // Try to extract entity class from getRepository(Entity::class)
+        let table = 'unknown';
+        const repoIdx = chain.names.indexOf('getRepository');
+        if (repoIdx !== -1 && chain.args[repoIdx]) {
+            const repoArgs = chain.args[repoIdx];
+            if (repoArgs && repoArgs.length > 0 && repoArgs[0]) {
+                const entityArg = repoArgs[0];
+                if (entityArg.type === 'class_constant_access_expression') {
+                    const classNode = entityArg.childForFieldName('class');
+                    if (classNode) {
+                        table = this.inferTableFromName(classNode.text);
+                    }
+                }
+            }
+        }
+        return this.createAccessPoint({
+            table,
+            fields: [],
+            operation,
+            file: filePath,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            context: node.text.slice(0, 200),
+            confidence: 0.9,
+        });
+    }
+    /**
+     * Try to match PDO pattern
+     * e.g., $pdo->query("SELECT..."), $stmt->execute()
+     */
+    tryPdoPattern(chain, node, filePath) {
+        if (chain.names.length < 2)
+            return null;
+        const varName = chain.names[0]?.toLowerCase() ?? '';
+        const methodName = chain.names[1];
+        // Check if it looks like PDO
+        const isPdo = varName.includes('pdo') || varName.includes('db') ||
+            varName.includes('conn') || varName.includes('stmt');
+        if (!isPdo)
+            return null;
+        const pdoMethods = {
+            read: ['query', 'prepare'],
+            write: ['exec', 'execute'],
+        };
+        let operation = null;
+        if (pdoMethods.read.includes(methodName ?? ''))
+            operation = 'read';
+        else if (pdoMethods.write.includes(methodName ?? ''))
+            operation = 'write';
+        if (!operation)
+            return null;
+        // Try to extract SQL
+        let table = 'unknown';
+        const methodArgs = chain.args[1];
+        if (methodArgs && methodArgs.length > 0) {
+            const sqlArg = methodArgs[0];
+            if (sqlArg) {
+                const sqlText = this.extractStringValue(sqlArg);
+                if (sqlText) {
+                    const parsed = this.parseSQLStatement(sqlText);
+                    table = parsed.table;
+                    if (parsed.operation !== 'unknown') {
+                        operation = parsed.operation;
+                    }
+                }
+            }
+        }
+        return this.createAccessPoint({
+            table,
+            fields: [],
+            operation,
+            file: filePath,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            context: node.text.slice(0, 200),
+            isRawSql: true,
+            confidence: 0.8,
+        });
+    }
+    /**
+     * Extract string value from a node
+     */
+    extractStringValue(node) {
+        if (!node)
+            return null;
+        // Handle argument wrapper
+        if (node.type === 'argument') {
+            const child = node.namedChildren[0];
+            if (child)
+                return this.extractStringValue(child);
+        }
+        if (node.type === 'string' || node.type === 'encapsed_string') {
+            // Remove quotes
+            return node.text.replace(/^['"]|['"]$/g, '');
+        }
+        return null;
+    }
+    /**
+     * Parse a SQL statement to extract table, operation, and fields
+     */
+    parseSQLStatement(sql) {
+        const upperSql = sql.toUpperCase().trim();
+        let operation = 'unknown';
+        let table = 'unknown';
+        const fields = [];
+        if (upperSql.startsWith('SELECT'))
+            operation = 'read';
+        else if (upperSql.startsWith('INSERT'))
+            operation = 'write';
+        else if (upperSql.startsWith('UPDATE'))
+            operation = 'write';
+        else if (upperSql.startsWith('DELETE'))
+            operation = 'delete';
+        const fromMatch = sql.match(/FROM\s+["'`]?(\w+)["'`]?/i);
+        const intoMatch = sql.match(/INTO\s+["'`]?(\w+)["'`]?/i);
+        const updateMatch = sql.match(/UPDATE\s+["'`]?(\w+)["'`]?/i);
+        if (fromMatch?.[1])
+            table = fromMatch[1];
+        else if (intoMatch?.[1])
+            table = intoMatch[1];
+        else if (updateMatch?.[1])
+            table = updateMatch[1];
+        return { table, operation, fields };
+    }
+}
+/**
+ * Create a PHP data access extractor
+ */
+export function createPhpDataAccessExtractor() {
+    return new PhpDataAccessExtractor();
+}
+//# sourceMappingURL=php-data-access-extractor.js.map