@archlast/cli 0.1.0

package/README.md

@@ -0,0 +1,149 @@
+# Archlast CLI
+
+CLI tool for Archlast development and deployment.
+
+## Installation
+
+### npm (recommended for users)
+
+```bash
+npm install -g @archlast/cli
+```
+
+### Local development (repo)
+
+```bash
+bun install
+bun run build
+```
+
+## Usage
+
+### Development Mode
+
+Watch for file changes and auto-generate types:
+
+```bash
+bun run archlast:dev
+# or
+bun archlast dev
+```
+
+Options:
+
+- `--path <path>` - Path to archlast folder (default: `./archlast`)
+- `--port <port>` - Server port (default: `3001`)
+- `--server <url>` - Server URL for code upload (default: `http://localhost:3001`)
+
+### Deploy Mode
+
+One-time deployment:
+
+```bash
+bun run archlast:deploy
+# or
+bun archlast deploy
+```
+
+Options:
+
+- `--path <path>` - Path to archlast folder (default: `./archlast`)
+- `--server <url>` - Server URL for code upload (default: `http://localhost:3001`)
+
+## Features
+
+- 📁 **File Watching**: Monitors `archlast/src/` folder for changes
+- 🔍 **Code Analysis**: Detects functions (query, mutation, action) and schema changes
+- 🎯 **Type Generation**: Auto-generates client-side TypeScript types to `_generated/`
+- 🔄 **Diff Detection**: Shows added, modified, and removed functions
+- ⚡ **Fast Rebuilds**: Only regenerates on actual changes
+- 🌐 **HTTP Upload**: Uploads code to server via `/_archlast/deploy` endpoint
+
+## How It Works
+
+1. Watches all `.ts` files in the `archlast/src/` folder
+2. Analyzes exports to find `query`, `mutation`, and `action` functions
+3. Detects schema changes in `src/schema.ts`
+4. Generates type definitions in `archlast/_generated/api.ts`
+5. **Uploads code to server via HTTP** (POST to `/_archlast/deploy`)
+6. Shows a diff of changes in the console
+
+## Project Structure
+
+```
+archlast/
+├── src/              # Your function definitions
+│   ├── schema.ts     # Database schema
+│   ├── tasks.ts      # Function exports
+│   └── ...
+├── _generated/       # Auto-generated by CLI
+│   ├── api.ts        # Type-safe API object
+│   ├── index.ts      # Barrel export
+│   └── server.ts     # Server types (manual)
+├── package.json
+└── tsconfig.json
+```
+
+Run `bun run dev` from the archlast folder to start development mode.
+
+Similar to Convex's `npx convex dev` workflow.
+
+## Server Endpoint
+
+The server receives deployments at `POST /_archlast/deploy` with payload:
+
+```typescript
+{
+  functions: Array<{
+    name: string;
+    type: 'query' | 'mutation' | 'action';
+    filePath: string;
+    code: string;
+  }>;
+  schema: {
+    filePath: string;
+    code: string;
+  } | null;
+  timestamp: number;
+}
+```
+
+Server responds with:
+
+```typescript
+{
+    success: boolean;
+    message: string;
+    functions: number;
+    schema: boolean;
+}
+```
+
+Similar to Convex's `npx convex dev` workflow.
+
+## Testing
+
+Run the test suite:
+
+```bash
+bun test
+```
+
+Run with coverage:
+
+```bash
+bun test --coverage
+```
+
+The test suite includes:
+
+- **Unit tests**: Individual module testing (analyzer, generator, uploader, watcher, DI generator)
+- **Integration tests**: Command orchestration (dev, deploy)
+- **CLI tests**: Entry point and command parsing
+- **Fixtures**: Comprehensive test data for malformed exports, complex handlers, schema variations, and mock manifests
+
+Coverage target: 90%+ lines/branches/functions
+
+## Publishing (maintainers)
+
+See `docs/npm-publishing.md` for the release workflow and manual publish steps.

package/dist/analyzer.d.ts

@@ -0,0 +1,96 @@
+export interface FunctionDefinition {
+    name: string;
+    type: "query" | "mutation" | "action";
+    filePath: string;
+    hash: string;
+}
+export interface HttpRouteDefinition {
+    name: string;
+    type: "http" | "webhook";
+    method: string;
+    path: string;
+    filePath: string;
+    hash: string;
+}
+export interface RpcDefinition {
+    name: string;
+    procedureType: "query" | "mutation";
+    filePath: string;
+    moduleName: string;
+    hash: string;
+}
+export interface InjectableDefinition {
+    className: string;
+    provide: string;
+    implementation: string;
+    filePath: string;
+    hash: string;
+}
+export interface SchemaDefinition {
+    tables: Record<string, any>;
+    hash: string;
+    /** Path to the schema file (for merged schemas, indicates "schema/*.ts") */
+    filePath?: string;
+    /** For merged schemas, list of all schema files that were combined */
+    files?: string[];
+}
+export interface AnalysisResult {
+    functions: FunctionDefinition[];
+    httpRoutes: HttpRouteDefinition[];
+    rpcRoutes: RpcDefinition[];
+    injectables: InjectableDefinition[];
+    schema: SchemaDefinition | string | null;
+    timestamp: number;
+}
+export declare class CodeAnalyzer {
+    private archlastPath;
+    constructor(archlastPath: string);
+    analyze(): Promise<AnalysisResult>;
+    private analyzeFunctions;
+    private analyzeHttpRoutes;
+    private analyzeRpcRoutes;
+    private analyzeInjectables;
+    /**
+     * Analyze schema definition
+     * Supports both single-file (schema.ts) and folder-based (schema/*.ts) schemas
+     * Priority: Single file > Folder with index.ts > Folder (scanned and merged)
+     */
+    private analyzeSchema;
+    /**
+     * Parse a single schema file
+     */
+    private parseSchemaFile;
+    /**
+     * Scan schema folder for all .ts files
+     */
+    private scanSchemaFolder;
+    /**
+     * Merge multiple schema files into a single schema definition
+     * Later files override earlier ones for conflicting table names
+     */
+    private mergeSchemaFiles;
+    /**
+     * Extract table definitions from schema content
+     * Uses regex parsing to find defineTable calls
+     */
+    private extractTablesFromSchema;
+    private hashString;
+}
+export declare class CodeDiffer {
+    diff(prev: AnalysisResult, current: AnalysisResult): {
+        added: FunctionDefinition[];
+        removed: FunctionDefinition[];
+        modified: FunctionDefinition[];
+        addedRoutes: HttpRouteDefinition[];
+        removedRoutes: HttpRouteDefinition[];
+        modifiedRoutes: HttpRouteDefinition[];
+        addedRpcRoutes: RpcDefinition[];
+        removedRpcRoutes: RpcDefinition[];
+        modifiedRpcRoutes: RpcDefinition[];
+        addedInjectables: InjectableDefinition[];
+        removedInjectables: InjectableDefinition[];
+        modifiedInjectables: InjectableDefinition[];
+        schemaChanged: boolean;
+    };
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,OAAO,GAAG,UAAU,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,MAAM,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAAC;IACzC,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,YAAY;IACrB,OAAO,CAAC,YAAY,CAAS;gBAEjB,YAAY,EAAE,MAAM;IAI1B,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;YAiB1B,gBAAgB;YAuDhB,iBAAiB;YAmDjB,gBAAgB;YAgDhB,kBAAkB;IAkEhC;;;;OAIG;YACW,aAAa;IAgC3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;YACW,gBAAgB;IAuB9B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAoB/B,OAAO,CAAC,UAAU;CASrB;AAED,qBAAa,UAAU;IACnB,IAAI,CACA,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,cAAc,GACxB;QACC,KAAK,EAAE,kBAAkB,EAAE,CAAC;QAC5B,OAAO,EAAE,kBAAkB,EAAE,CAAC;QAC9B,QAAQ,EAAE,kBAAkB,EAAE,CAAC;QAC/B,WAAW,EAAE,mBAAmB,EAAE,CAAC;QACnC,aAAa,EAAE,mBAAmB,EAAE,CAAC;QACrC,cAAc,EAAE,mBAAmB,EAAE,CAAC;QACtC,cAAc,EAAE,aAAa,EAAE,CAAC;QAChC,gBAAgB,EAAE,aAAa,EAAE,CAAC;QAClC,iBAAiB,EAAE,aAAa,EAAE,CAAC;QACnC,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;QACzC,kBAAkB,EAAE,oBAAoB,EAAE,CAAC;QAC3C,mBAAmB,EAAE,oBAAoB,EAAE,CAAC;QAC5C,aAAa,EAAE,OAAO,CAAC;KAC1B;CAsHJ"}

package/dist/analyzer.js

@@ -0,0 +1,404 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+export class CodeAnalyzer {
+    archlastPath;
+    constructor(archlastPath) {
+        this.archlastPath = path.resolve(archlastPath);
+    }
+    async analyze() {
+        const functions = await this.analyzeFunctions();
+        const httpRoutes = await this.analyzeHttpRoutes();
+        const rpcRoutes = await this.analyzeRpcRoutes();
+        const injectables = await this.analyzeInjectables();
+        const schema = await this.analyzeSchema();
+        return {
+            functions,
+            httpRoutes,
+            rpcRoutes,
+            injectables,
+            schema,
+            timestamp: Date.now(),
+        };
+    }
+    async analyzeFunctions() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const functions = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            // Simple regex to detect exported functions
+            const queryMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*query\s*\(/g);
+            const mutationMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*mutation\s*\(/g);
+            const actionMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*action\s*\(/g);
+            for (const match of queryMatches) {
+                functions.push({
+                    name: match[1],
+                    type: "query",
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            for (const match of mutationMatches) {
+                functions.push({
+                    name: match[1],
+                    type: "mutation",
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            for (const match of actionMatches) {
+                functions.push({
+                    name: match[1],
+                    type: "action",
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return functions;
+    }
+    async analyzeHttpRoutes() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const routes = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            // Detect http.get, http.post, etc.
+            // Use [\s\S]*? to handle multiline object definitions
+            const httpMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*http\.(get|post|put|delete|patch)\s*\(\s*\{[\s\S]*?path:\s*["']([^"']+)["']/g);
+            for (const match of httpMatches) {
+                routes.push({
+                    name: match[1],
+                    type: "http",
+                    method: match[2].toUpperCase(),
+                    path: match[3],
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            // Detect webhook definitions
+            const webhookMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*webhook\s*\(\s*\{[^}]*path:\s*["']([^"']+)["']/g);
+            for (const match of webhookMatches) {
+                routes.push({
+                    name: match[1],
+                    type: "webhook",
+                    method: "POST",
+                    path: match[2],
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return routes;
+    }
+    async analyzeRpcRoutes() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const routes = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            const moduleName = relativePath.replace(/\.ts$/, "");
+            // Detect rpc.query definitions
+            const queryMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*rpc\.query\s*\(/g);
+            for (const match of queryMatches) {
+                routes.push({
+                    name: match[1],
+                    procedureType: "query",
+                    filePath: relativePath,
+                    moduleName,
+                    hash: this.hashString(content),
+                });
+            }
+            // Detect rpc.mutation definitions
+            const mutationMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*rpc\.mutation\s*\(/g);
+            for (const match of mutationMatches) {
+                routes.push({
+                    name: match[1],
+                    procedureType: "mutation",
+                    filePath: relativePath,
+                    moduleName,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return routes;
+    }
+    async analyzeInjectables() {
+        const pattern = path.join(this.archlastPath, "src", "**/*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**", "**/schema.ts"],
+        });
+        const injectables = [];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf-8");
+            const srcPath = path.join(this.archlastPath, "src");
+            const relativePath = path.relative(srcPath, file);
+            // Detect @Injectable() decorators
+            // Pattern: @Injectable({ provide: 'Token', useFactory: 'Implementation' })
+            // or @Injectable() for simple cases
+            const decoratorMatches = content.matchAll(/@Injectable\s*\(\s*(?:\{([^}]*)\})?\s*\)\s*(?:export\s+)?class\s+(\w+)/g);
+            for (const match of decoratorMatches) {
+                const optionsStr = match[1] || "";
+                const className = match[2];
+                // Parse options
+                let provide = className;
+                let implementation = "default";
+                const provideMatch = optionsStr.match(/provide:\s*["']([^"']+)["']/);
+                if (provideMatch) {
+                    provide = provideMatch[1];
+                }
+                const factoryMatch = optionsStr.match(/useFactory:\s*["']([^"']+)["']/);
+                if (factoryMatch) {
+                    implementation = factoryMatch[1];
+                }
+                injectables.push({
+                    className,
+                    provide,
+                    implementation,
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+            // Also detect @Factory decorator
+            const factoryMatches = content.matchAll(/@Factory\s*\(\s*["']([^"']+)["']\s*,\s*["']([^"']+)["']\s*\)\s*(?:export\s+)?class\s+(\w+)/g);
+            for (const match of factoryMatches) {
+                injectables.push({
+                    className: match[3],
+                    provide: match[1],
+                    implementation: match[2],
+                    filePath: relativePath,
+                    hash: this.hashString(content),
+                });
+            }
+        }
+        return injectables;
+    }
+    /**
+     * Analyze schema definition
+     * Supports both single-file (schema.ts) and folder-based (schema/*.ts) schemas
+     * Priority: Single file > Folder with index.ts > Folder (scanned and merged)
+     */
+    async analyzeSchema() {
+        const srcPath = path.join(this.archlastPath, "src");
+        const singleSchemaPath = path.join(srcPath, "schema.ts");
+        const schemaFolderPath = path.join(srcPath, "schema");
+        const schemaIndexPath = path.join(schemaFolderPath, "index.ts");
+        // Check for single schema file first (highest priority)
+        if (fs.existsSync(singleSchemaPath)) {
+            const content = fs.readFileSync(singleSchemaPath, "utf-8");
+            return this.parseSchemaFile(singleSchemaPath, content);
+        }
+        // Check for schema folder
+        if (!fs.existsSync(schemaFolderPath)) {
+            return null;
+        }
+        // Check for schema/index.ts
+        if (fs.existsSync(schemaIndexPath)) {
+            const content = fs.readFileSync(schemaIndexPath, "utf-8");
+            return this.parseSchemaFile(schemaIndexPath, content);
+        }
+        // Scan and merge all schema files in folder
+        const schemaFiles = await this.scanSchemaFolder(schemaFolderPath);
+        if (schemaFiles.length === 0) {
+            return null;
+        }
+        return this.mergeSchemaFiles(schemaFiles);
+    }
+    /**
+     * Parse a single schema file
+     */
+    parseSchemaFile(filePath, content) {
+        return {
+            tables: this.extractTablesFromSchema(content),
+            filePath: path.relative(this.archlastPath, filePath),
+            hash: this.hashString(content),
+        };
+    }
+    /**
+     * Scan schema folder for all .ts files
+     */
+    async scanSchemaFolder(folderPath) {
+        const pattern = path.join(folderPath, "*.ts").replace(/\\/g, "/");
+        const files = await glob(pattern, {
+            ignore: ["**/node_modules/**", "**/_generated/**"],
+        });
+        const schemaFiles = [];
+        for (const file of files) {
+            // Skip index.ts as it's handled separately
+            if (path.basename(file) === "index.ts") {
+                continue;
+            }
+            const content = fs.readFileSync(file, "utf-8");
+            schemaFiles.push({
+                filePath: file,
+                content,
+            });
+        }
+        return schemaFiles;
+    }
+    /**
+     * Merge multiple schema files into a single schema definition
+     * Later files override earlier ones for conflicting table names
+     */
+    mergeSchemaFiles(schemaFiles) {
+        const tables = {};
+        const hashes = [];
+        for (const { filePath, content } of schemaFiles) {
+            const fileTables = this.extractTablesFromSchema(content);
+            // Merge tables (later files override)
+            Object.assign(tables, fileTables);
+            hashes.push(this.hashString(content));
+        }
+        // Combined hash from all files
+        const combinedHash = this.hashString(hashes.join("|"));
+        return {
+            tables,
+            filePath: "schema/*.ts", // Indicator that this is a merged schema
+            hash: combinedHash,
+            files: schemaFiles.map(f => path.relative(this.archlastPath, f.filePath)),
+        };
+    }
+    /**
+     * Extract table definitions from schema content
+     * Uses regex parsing to find defineTable calls
+     */
+    extractTablesFromSchema(content) {
+        const tables = {};
+        // Pattern to match defineTable calls
+        // export const <tableName> = defineTable({ ... }, options?)
+        const tableMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)\s*=\s*defineTable\s*\(\s*\{([^}]+)\}/g);
+        for (const match of tableMatches) {
+            const tableName = match[1];
+            tables[tableName] = {
+                name: tableName,
+                fields: match[2] || "",
+            };
+        }
+        return tables;
+    }
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    }
+}
+export class CodeDiffer {
+    diff(prev, current) {
+        const prevFuncMap = new Map(prev.functions.map((f) => [f.name, f]));
+        const currFuncMap = new Map(current.functions.map((f) => [f.name, f]));
+        const added = [];
+        const removed = [];
+        const modified = [];
+        // Find added and modified functions
+        for (const [name, func] of currFuncMap) {
+            const prevFunc = prevFuncMap.get(name);
+            if (!prevFunc) {
+                added.push(func);
+            }
+            else if (prevFunc.hash !== func.hash) {
+                modified.push(func);
+            }
+        }
+        // Find removed functions
+        for (const [name, func] of prevFuncMap) {
+            if (!currFuncMap.has(name)) {
+                removed.push(func);
+            }
+        }
+        // Diff HTTP routes
+        const prevRouteMap = new Map((prev.httpRoutes || []).map((r) => [r.name, r]));
+        const currRouteMap = new Map((current.httpRoutes || []).map((r) => [r.name, r]));
+        const addedRoutes = [];
+        const removedRoutes = [];
+        const modifiedRoutes = [];
+        for (const [name, route] of currRouteMap) {
+            const prevRoute = prevRouteMap.get(name);
+            if (!prevRoute) {
+                addedRoutes.push(route);
+            }
+            else if (prevRoute.hash !== route.hash) {
+                modifiedRoutes.push(route);
+            }
+        }
+        for (const [name, route] of prevRouteMap) {
+            if (!currRouteMap.has(name)) {
+                removedRoutes.push(route);
+            }
+        }
+        // Diff RPC routes
+        const prevRpcMap = new Map((prev.rpcRoutes || []).map((r) => [`${r.moduleName}.${r.name}`, r]));
+        const currRpcMap = new Map((current.rpcRoutes || []).map((r) => [`${r.moduleName}.${r.name}`, r]));
+        const addedRpcRoutes = [];
+        const removedRpcRoutes = [];
+        const modifiedRpcRoutes = [];
+        for (const [fullName, route] of currRpcMap) {
+            const prevRoute = prevRpcMap.get(fullName);
+            if (!prevRoute) {
+                addedRpcRoutes.push(route);
+            }
+            else if (prevRoute.hash !== route.hash) {
+                modifiedRpcRoutes.push(route);
+            }
+        }
+        for (const [fullName, route] of prevRpcMap) {
+            if (!currRpcMap.has(fullName)) {
+                removedRpcRoutes.push(route);
+            }
+        }
+        // Diff injectables
+        const prevInjectableMap = new Map((prev.injectables || []).map((i) => [`${i.provide}:${i.implementation}`, i]));
+        const currInjectableMap = new Map((current.injectables || []).map((i) => [`${i.provide}:${i.implementation}`, i]));
+        const addedInjectables = [];
+        const removedInjectables = [];
+        const modifiedInjectables = [];
+        for (const [key, injectable] of currInjectableMap) {
+            const prevInjectable = prevInjectableMap.get(key);
+            if (!prevInjectable) {
+                addedInjectables.push(injectable);
+            }
+            else if (prevInjectable.hash !== injectable.hash) {
+                modifiedInjectables.push(injectable);
+            }
+        }
+        for (const [key, injectable] of prevInjectableMap) {
+            if (!currInjectableMap.has(key)) {
+                removedInjectables.push(injectable);
+            }
+        }
+        const prevHash = typeof prev.schema === "string" ? prev.schema : prev.schema?.hash;
+        const currHash = typeof current.schema === "string" ? current.schema : current.schema?.hash;
+        const schemaChanged = prevHash !== currHash;
+        return {
+            added,
+            removed,
+            modified,
+            addedRoutes,
+            removedRoutes,
+            modifiedRoutes,
+            addedRpcRoutes,
+            removedRpcRoutes,
+            modifiedRpcRoutes,
+            addedInjectables,
+            removedInjectables,
+            modifiedInjectables,
+            schemaChanged,
+        };
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1,14 @@
+export declare function validateApiKey(apiKey: string): {
+    valid: boolean;
+    error?: string;
+};
+export declare class AdminTokenNotFoundError extends Error {
+    constructor();
+}
+export declare function isBetterAuthApiKey(token: string): boolean;
+export declare function extractFromEnv(content: string, varName: string): string | null;
+export declare function readAdminToken(archlastPath?: string): string;
+export declare function getAuthHeaders(archlastPath?: string): Record<string, string>;
+export declare function hashString(str: string): string;
+export declare function hashFile(filePath: string): string;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAMA,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAcjF;AAED,qBAAa,uBAAwB,SAAQ,KAAK;;CAUjD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY9E;AAED,wBAAgB,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CA2C5D;AAED,wBAAgB,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK5E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOjD"}