@ductape/cli 0.3.36 → 0.4.1

package/dist/commands/sessions-validate.d.ts

@@ -0,0 +1,3 @@
+export declare function runSessionsValidate(opts?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/sessions-validate.js

@@ -0,0 +1,12 @@
+import { findProjectConfig } from '../lib/config.js';
+import { fail } from '../lib/output.js';
+import { formatSessionConformance, validateSessionConformance } from '../lib/session-conformance.js';
+export async function runSessionsValidate(opts = {}) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory (or `ductape init`).');
+    const result = validateSessionConformance(found.dir);
+    console.log(opts.json ? JSON.stringify(result, null, 2) : formatSessionConformance(result));
+    if (!result.ok)
+        process.exitCode = 1;
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { runDb, runDbActions, runDbContext } from './commands/db.js';
 import { runComponentActions } from './commands/component-actions.js';
 import { runDbMigrate, runDbMigrateStatus, runDbMigrateRollback } from './commands/db-migrate.js';
 import { runFeaturesSync, runFeaturesValidate } from './commands/features-sync.js';
+import { runSessionsValidate } from './commands/sessions-validate.js';
 import { runDbSchemaGenerate, runDbSchemaPush } from './commands/db-schema.js';
 import { runGraph } from './commands/graph.js';
 import { runSecretImportEnv, runSecrets } from './commands/secrets.js';
@@ -895,6 +896,12 @@ db
     return runDb(verb, { file: opts.file, json: opts.json });
 }));
 const features = program.command('features').description('Code-first Ductape Features (ductape/features/)');
+const sessions = program.command('sessions').description('Session lifecycle and propagation checks');
+sessions
+    .command('validate')
+    .description('Read-only project-wide audit of Ductape SDK session propagation')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runSessionsValidate({ json: Boolean(opts.json) })));
 features
     .command('validate')
     .description('Read-only AST validation of code-first Feature control flow; performs no remote mutation')

package/dist/lib/db-types.d.ts

@@ -45,7 +45,19 @@ export interface ICreateIndexOp {
         order?: 'asc' | 'desc';
     }>;
     unique?: boolean;
+    sparse?: boolean;
     ifNotExists?: boolean;
+    sqlOptions?: {
+        method?: string;
+        where?: string;
+        include?: string[];
+        concurrent?: boolean;
+    };
+    mongoOptions?: {
+        expireAfterSeconds?: number;
+        partialFilterExpression?: Record<string, unknown>;
+        collation?: Record<string, unknown>;
+    };
 }
 export interface IDropIndexOp {
     type: 'dropIndex';

package/dist/lib/migration-files.d.ts

@@ -1,4 +1,5 @@
 import type { IMigration } from './db-types.js';
+export declare function validateEquivalentMigrationIndexes(migrations: IMigration[]): void;
 export declare function getMigrationsDir(projectDir: string, dbTag: string): string;
 export declare function loadMigrationFiles(projectDir: string, dbTag: string): IMigration[];
 export declare function writeMigrationFile(projectDir: string, dbTag: string, migration: IMigration, counter: number): string;

package/dist/lib/migration-files.js

@@ -1,6 +1,27 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { PROJECT_CONFIG_DIR } from './config.js';
+function stable(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => `${JSON.stringify(key)}:${stable(nested)}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+export function validateEquivalentMigrationIndexes(migrations) {
+    const seen = new Map();
+    for (const migration of migrations)
+        migration.up.forEach((operation, operationIndex) => {
+            if (operation.type !== 'createIndex')
+                return;
+            const fingerprint = stable({ collection: operation.collection, fields: operation.fields.map((field) => ({ name: field.name, order: field.order ?? 'asc' })), unique: Boolean(operation.unique), sparse: Boolean(operation.sparse), sql: operation.sqlOptions ?? {}, mongo: operation.mongoOptions ?? {} });
+            const previous = seen.get(fingerprint);
+            if (previous && previous.name !== operation.name) {
+                throw new Error(`Equivalent index definitions use different names: migration "${previous.migration}" operation ${previous.operation + 1} creates "${previous.name}", while migration "${migration.tag}" operation ${operationIndex + 1} creates "${operation.name}".`);
+            }
+            seen.set(fingerprint, { migration: migration.tag, operation: operationIndex, name: operation.name });
+        });
+}
 export function getMigrationsDir(projectDir, dbTag) {
     return path.join(projectDir, PROJECT_CONFIG_DIR, 'database', 'migrations', dbTag);
 }
@@ -12,10 +33,12 @@ export function loadMigrationFiles(projectDir, dbTag) {
         .readdirSync(dir)
         .filter((f) => f.endsWith('.json'))
         .sort();
-    return files.map((file) => {
+    const migrations = files.map((file) => {
         const raw = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
         return raw;
     });
+    validateEquivalentMigrationIndexes(migrations);
+    return migrations;
 }
 function makeTimestamp(counter) {
     const now = new Date();

package/dist/lib/session-conformance.d.ts

@@ -0,0 +1,16 @@
+export type SessionClassification = 'explicit' | 'inherited' | 'delegated' | 'system' | 'missing';
+export interface SessionFinding {
+    file: string;
+    line: number;
+    call: string;
+    classification: SessionClassification;
+    reason?: string;
+}
+export interface SessionValidationResult {
+    ok: boolean;
+    root: string;
+    summary: Record<SessionClassification | 'calls', number>;
+    findings: SessionFinding[];
+}
+export declare function validateSessionConformance(rootDir: string): SessionValidationResult;
+export declare function formatSessionConformance(result: SessionValidationResult): string;

package/dist/lib/session-conformance.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+const IGNORED = new Set(['.git', 'dist', 'build', 'coverage', 'node_modules']);
+const CALL = /\b(?:ductape\.)?(api|feature|database|databases|graph|vector|storage|events|notifications|quota|fallback)\.([A-Za-z_$][\w$]*)\s*\(/g;
+function walk(root, files) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (entry.isSymbolicLink() || IGNORED.has(entry.name))
+            continue;
+        const target = path.join(root, entry.name);
+        if (entry.isDirectory())
+            walk(target, files);
+        else if (EXTENSIONS.has(path.extname(entry.name)))
+            files.push(target);
+    }
+}
+function invocation(source, open) {
+    let depth = 0;
+    let quote = '';
+    let escaped = false;
+    for (let i = open; i < source.length; i += 1) {
+        const char = source[i];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === quote)
+                quote = '';
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            depth += 1;
+        if (char === ')' && --depth === 0)
+            return source.slice(open + 1, i);
+    }
+    return source.slice(open + 1);
+}
+export function validateSessionConformance(rootDir) {
+    const root = path.resolve(rootDir);
+    const files = [];
+    walk(root, files);
+    const findings = [];
+    for (const file of files) {
+        const source = fs.readFileSync(file, 'utf8');
+        let match;
+        while ((match = CALL.exec(source))) {
+            const call = `${match[1]}.${match[2]}`;
+            const line = source.slice(0, match.index).split('\n').length;
+            const args = invocation(source, source.indexOf('(', match.index));
+            const nearby = source.slice(Math.max(0, match.index - 300), match.index);
+            let classification = 'missing';
+            let reason;
+            if (/\bsession\s*:/.test(args))
+                classification = 'explicit';
+            else if (/\bctx\.$/.test(nearby))
+                classification = 'inherited';
+            else {
+                const marker = nearby.match(/ductape-session:\s*(delegated|system)\s+([^\n]+)/i);
+                if (marker) {
+                    classification = marker[1].toLowerCase();
+                    reason = marker[2].trim();
+                }
+            }
+            findings.push({ file: path.relative(root, file).split(path.sep).join('/'), line, call, classification, reason });
+        }
+    }
+    const summary = { calls: findings.length, explicit: 0, inherited: 0, delegated: 0, system: 0, missing: 0 };
+    for (const finding of findings)
+        summary[finding.classification] += 1;
+    return { ok: summary.missing === 0, root, summary, findings };
+}
+export function formatSessionConformance(result) {
+    const lines = [`Session propagation: ${result.ok ? 'PASS' : 'FAIL'} (${result.summary.calls} calls)`];
+    for (const finding of result.findings.filter((item) => item.classification === 'missing'))
+        lines.push(`  ${finding.file}:${finding.line} ${finding.call} has no explicit, inherited, delegated, or system session classification`);
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.3.36",
+  "version": "0.4.1",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",