noormme 1.2.0 → 1.2.1

package/dist/esm/migration/data_migrator.js

@@ -21,10 +21,10 @@ export async function migrateTableData(sourceDb, targetDb, sourceTable, targetTa
                 errors: [],
             };
         }
-        // Keyset pagination optimization: find a numeric primary key
-        const pkColumn = sourceTable.columns.find((c) => c.primaryKey &&
-            (c.type.toLowerCase().includes('int') ||
-                c.type.toLowerCase().includes('serial')))?.name;
+        // Keyset pagination optimization: find a primary key or a unique single-column index
+        const pkColumn = sourceTable.columns.find((c) => c.primaryKey)?.name ||
+            sourceTable.indexes.find((i) => i.unique && i.columns.length === 1)
+                ?.columns[0];
         let lastId = null;
         // Calculate number of batches (approximate)
         const batchCount = Math.ceil(totalRows / options.batchSize);

package/dist/esm/migration/schema_differ.js

@@ -175,24 +175,46 @@ function compareIndexes(sourceTable, targetTable) {
 }
 function compareConstraints(sourceTable, targetTable) {
     const differences = [];
-    // Simple comparison - just check counts for now
-    if (sourceTable.constraints.length > targetTable.constraints.length) {
-        differences.push({
-            type: 'constraint_added',
-            table: sourceTable.name,
-            details: {
-                message: `${sourceTable.constraints.length - targetTable.constraints.length} constraint(s) need to be added`,
-            },
+    // PRODUCTION HARDENING: Deep Structural Audit
+    const sourceConstraints = sourceTable.constraints || [];
+    const targetConstraints = targetTable.constraints || [];
+    for (const source of sourceConstraints) {
+        const matching = targetConstraints.find((t) => {
+            const typeMatch = t.type === source.type;
+            const exprMatch = t.expression === source.expression;
+            const colsMatch = JSON.stringify(t.columns?.sort()) ===
+                JSON.stringify(source.columns?.sort());
+            return typeMatch && (source.type === 'CHECK' ? exprMatch : colsMatch);
         });
+        if (!matching) {
+            differences.push({
+                type: 'constraint_added',
+                table: sourceTable.name,
+                details: {
+                    source,
+                    message: `Constraint of type ${source.type} ${source.name ? `'${source.name}' ` : ''}needs to be added`,
+                },
+            });
+        }
     }
-    else if (sourceTable.constraints.length < targetTable.constraints.length) {
-        differences.push({
-            type: 'constraint_removed',
-            table: sourceTable.name,
-            details: {
-                message: `${targetTable.constraints.length - sourceTable.constraints.length} constraint(s) exist in target but not in source`,
-            },
+    for (const target of targetConstraints) {
+        const matching = sourceConstraints.find((s) => {
+            const typeMatch = s.type === target.type;
+            const exprMatch = s.expression === target.expression;
+            const colsMatch = JSON.stringify(s.columns?.sort()) ===
+                JSON.stringify(target.columns?.sort());
+            return typeMatch && (target.type === 'CHECK' ? exprMatch : colsMatch);
         });
+        if (!matching) {
+            differences.push({
+                type: 'constraint_removed',
+                table: sourceTable.name,
+                details: {
+                    target,
+                    message: `Constraint of type ${target.type} ${target.name ? `'${target.name}' ` : ''}exists in target but not in source`,
+                },
+            });
+        }
     }
     return differences;
 }

package/dist/esm/types/index.d.ts

@@ -385,6 +385,18 @@ export interface AgentPersona {
     createdAt: Date;
     updatedAt: Date;
 }
+export interface AgentQuota {
+    id: string | number;
+    targetType: 'persona' | 'swarm' | 'global';
+    targetId: string | null;
+    metric: 'cost' | 'tokens_input' | 'tokens_output' | 'tokens_total';
+    limit: number;
+    period: 'hourly' | 'daily' | 'monthly' | 'infinite';
+    currentUsage: number;
+    metadata?: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
 export interface AgentEpoch {
     id: string | number;
     sessionId: string | number;

package/dist/esm/util/safe-sql-helpers.js

@@ -138,16 +138,13 @@ export function safeCaseStatement(cases, elseResult) {
     if (cases.length === 0) {
         throw new Error('At least one WHEN clause is required');
     }
-    // Note: This function needs to be refactored to not use sql.raw()
-    // For now, we construct the CASE statement carefully
-    const whenClauses = cases
-        .map((c, i) => {
-        // Conditions must be RawBuilder instances to ensure they're safe
-        const conditionSql = c.condition.toOperationNode();
-        return `WHEN ${conditionSql} THEN ${c.result}`;
-    })
-        .join(' ');
-    return sql.raw(`CASE ${whenClauses} ELSE ${elseResult} END`);
+    // PRODUCTION HARDENING: Balanced Case Construction
+    // We avoid sql.raw() by building the CASE statement recursively or via template fragments
+    let caseBuilder = sql `CASE`;
+    for (const c of cases) {
+        caseBuilder = sql `${caseBuilder} WHEN ${c.condition} THEN ${sql.val(c.result)}`;
+    }
+    return sql `${caseBuilder} ELSE ${sql.val(elseResult)} END`;
 }
 /**
  * Example usage and best practices

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noormme",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "NOORMME - The Agentic Data Engine. High-fidelity persistence and cognitive governance for Autonomous AI Agents.",
   "repository": {
     "type": "git",