typed-bridge 1.0.0 → 2.0.0

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "editor.formatOnSave": true
+}

package/context.md

@@ -0,0 +1,168 @@
+# **Using `typed-bridge` to Build a Backend**
+
+## **What is `typed-bridge`?**
+
+`typed-bridge` is an open‑source TypeScript package that lets you define **strictly typed server functions** and automatically generate a matching **typed client** for your frontend.
+It removes the boilerplate of REST/GraphQL by letting you call server functions like local functions — while keeping **end‑to‑end type safety** between backend and frontend.
+It’s framework‑agnostic, works with any frontend (React, Vue, Angular, RN, etc.), supports middleware for auth/validation/logging, and has built‑in graceful shutdown and request logging.
+
+**Why use it?**
+
+- Prevents API spec drift between backend and frontend
+- Strong TypeScript type checking across the stack
+- Simple middleware for auth, validation, and context sharing
+- No need to hand‑roll REST/GraphQL routes
+
+---
+
+## **How to Start a Server**
+
+```ts
+// src/server.ts
+import { createBridge, tbConfig } from 'typed-bridge'
+import bridge from './bridge/index.js'
+import './middleware/auth.js' // optional middleware
+
+// Optional logging
+tbConfig.logs.request = true
+tbConfig.logs.response = true
+tbConfig.logs.error = true
+
+createBridge(bridge, 8080, '/bridge')
+console.log(`Bridge running at http://localhost:8080/bridge`)
+```
+
+---
+
+## **How to Define Routes**
+
+```ts
+// src/bridge/index.ts
+import * as user from './user/index.js'
+
+export default {
+    'user.fetch': user.fetch,
+    'user.update': user.update,
+    'user.fetchAll': user.fetchAll
+}
+```
+
+---
+
+## **How to Write Handlers**
+
+```ts
+// src/bridge/user/index.ts
+export interface User {
+    id: number
+    name: string
+    email: string
+    createdAt: Date
+}
+
+const users: User[] = [
+    { id: 1, name: 'Neil', email: 'neil@example.com', createdAt: new Date() },
+    { id: 2, name: 'John', email: 'john@example.com', createdAt: new Date() },
+    { id: 3, name: 'Jane', email: 'jane@example.com', createdAt: new Date() }
+]
+
+export const fetch = async (args: { id: number }): Promise<User> => {
+    const user = users.find(u => u.id === args.id)
+    if (!user) throw new Error(`User ${args.id} not found`)
+    return user
+}
+
+export const update = async (args: { id: number; name?: string; email?: string }): Promise<User> => {
+    const user = users.find(u => u.id === args.id)
+    if (!user) throw new Error(`User ${args.id} not found`)
+    if (args.name) user.name = args.name
+    if (args.email) user.email = args.email
+    return user
+}
+
+export const fetchAll = async (): Promise<User[]> => users
+```
+
+---
+
+## **How to Add Middleware**
+
+```ts
+// src/middleware/auth.ts
+import { createMiddleware } from 'typed-bridge'
+
+createMiddleware('user.*', async (req, res) => {
+    if (req.headers.authorization !== 'Bearer 123') {
+        res.status(401).send('Unauthorized')
+        return { next: false } // Stop processing
+    }
+    return { context: { userId: 999 } }
+})
+```
+
+---
+
+## **How to Validate with `$z` (Zod)**
+
+```ts
+// src/bridge/user/types.ts
+import { $z } from 'typed-bridge'
+
+export const fetch = {
+    args: $z.object({ id: $z.number().min(1) }),
+    res: $z.object({
+        id: $z.number(),
+        name: $z.string(),
+        email: $z.string().email(),
+        createdAt: $z.date()
+    })
+}
+```
+
+```ts
+// src/bridge/user/index.ts (validated version)
+import { $z } from 'typed-bridge'
+import * as types from './types.js'
+
+export const fetch = async (
+    args: $z.infer<typeof types.fetch.args>,
+    context: { userId?: number }
+): Promise<$z.infer<typeof types.fetch.res>> => {
+    args = types.fetch.args.parse(args)
+    const user = users.find(u => u.id === args.id)
+    if (!user) throw new Error(`User ${args.id} not found`)
+    return user
+}
+```
+
+---
+
+## **How to Generate a Typed Client**
+
+```bash
+npm run gen:typed-bridge-client
+# => creates ./bridge.ts
+```
+
+---
+
+## **How to Use the Generated Client (Frontend)**
+
+```ts
+import bridge, { bridgeConfig } from '../path-to-backend/bridge'
+
+bridgeConfig.host = 'http://localhost:8080/bridge'
+bridgeConfig.headers = { 'Content-Type': 'application/json', Authorization: 'Bearer 123' }
+
+const user = await bridge['user.fetch']({ id: 1 })
+console.log(user)
+```
+
+---
+
+## **How to Add a New Route (Checklist)**
+
+1. Create handler in `src/bridge/<module>/index.ts`
+2. Add `'module.method': handler` to `src/bridge/index.ts`
+3. (If validating) add types in `src/bridge/<module>/types.ts`
+4. Run `npm run gen:typed-bridge-client` to refresh the client

package/dist/bridge/index.d.ts

@@ -1,6 +1,19 @@
-import { Request, Response } from 'express';
-declare const _default: (bridge: any, contextParser?: (req: Request, res: Response) => Promise<{
-    next?: boolean;
-    context?: any;
-} | void>) => any;
-export default _default;
+import { Application, Request, Response } from 'express';
+import { Server } from 'http';
+type Bridge = {
+    [key: string]: (...args: any[]) => Promise<any>;
+};
+type Middleware = {
+    pattern: string;
+    handler: (req: Request, res: Response) => Promise<{
+        next?: boolean;
+        context?: any;
+    } | void>;
+};
+export declare const createMiddleware: (pattern: string, handler: Middleware["handler"]) => number;
+export declare const onShutdown: (fn: () => void) => () => void;
+export declare const createBridge: (bridge: Bridge, port: number, path?: string) => {
+    app: Application;
+    server: Server;
+};
+export {};

package/dist/bridge/index.js

@@ -1,23 +1,121 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("../config");
-exports.default = (bridge, contextParser) => async (req, res) => {
+exports.createBridge = exports.onShutdown = exports.createMiddleware = void 0;
+const helpers_1 = require("@/helpers");
+const chalk_1 = __importDefault(require("chalk"));
+const compression_1 = __importDefault(require("compression"));
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const __1 = require("..");
+const middlewares = [];
+const createMiddleware = (pattern, handler) => middlewares.push({ pattern, handler });
+exports.createMiddleware = createMiddleware;
+let shutdownCallback = () => { };
+const onShutdown = (fn) => (shutdownCallback = fn);
+exports.onShutdown = onShutdown;
+const createBridge = (bridge, port, path = '/bridge') => {
+    const app = (0, express_1.default)();
+    // cors
+    app.use((0, cors_1.default)());
+    // Compression
+    app.use((0, compression_1.default)());
+    // Body parser
+    app.use(express_1.default.json());
+    app.use(express_1.default.urlencoded({ extended: true }));
+    // Typed bridge middleware
+    let requestId = 1;
+    app.use((req, res, next) => {
+        const _req = req;
+        const xForwardedFor = req.headers['x-forwarded-for'];
+        let ip = Array.isArray(xForwardedFor)
+            ? xForwardedFor[0]
+            : (xForwardedFor || '').split(', ')[0] || req.socket.remoteAddress || '';
+        if (ip === '::1')
+            ip = '127.0.0.1';
+        // Bind data
+        _req.bind = {
+            id: 0,
+            ts: Date.now(),
+            args: {},
+            ip
+        };
+        // Set typed bridge header
+        res.setHeader('X-Powered-By', 'typed-bridge');
+        requestId++;
+        // Log request
+        if (__1.tbConfig.logs.request) {
+            console.log(chalk_1.default.blueBright(`REQ | ${new Date().toISOString()} | ${requestId} :: ${req.method} | ${req.path} | ${ip}`));
+        }
+        // Log response
+        const startTime = Date.now();
+        res.on('finish', () => {
+            const log = `RES | ${new Date().toISOString()} | ${requestId} :: ${res.statusCode} | ${Date.now() - startTime}ms`;
+            if (__1.tbConfig.logs.response)
+                console.log(res.statusCode < 400 ? chalk_1.default.green(log) : chalk_1.default.red(log));
+        });
+        next();
+    });
+    // Handle invalid json in post request
+    app.use((error, req, res, next) => {
+        if (error?.type === 'entity.parse.failed') {
+            res.status(400).send('Can not parse request!');
+        }
+        else
+            next();
+    });
+    // Custom responseDelay
+    if (__1.tbConfig.responseDelay)
+        app.use((req, res, next) => {
+            setTimeout(next, __1.tbConfig.responseDelay);
+        });
+    // Server health
+    app.use(path_1.default.join(path, 'health'), (req, res) => {
+        res.sendStatus(200);
+    });
+    app.use(path, bridgeHandler(bridge));
+    const server = app.listen(port, () => (0, helpers_1.printStartLogs)(port));
+    let shuttingDown = false;
+    const shutdown = () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        server.close();
+        (0, helpers_1.printStopLogs)();
+        shutdownCallback();
+    };
+    process.on('SIGINT', () => shutdown());
+    process.on('SIGTERM', () => shutdown());
+    return { app, server };
+};
+exports.createBridge = createBridge;
+const bridgeHandler = (bridge) => async (req, res) => {
     try {
         const path = req.path.split('/').pop() || '';
         const args = req.body;
         if (!path)
             throw new Error('Bridge not found!');
         const serverFunction = bridge[path];
-        if (!serverFunction)
-            throw new Error('Bridge not found: ' + path);
-        let context;
-        if (contextParser) {
-            const contextParserRes = await contextParser(req, res);
-            if (contextParserRes && contextParserRes.next === false)
-                return;
-            context = contextParserRes?.context;
+        if (!serverFunction) {
+            const error = 'Bridge not found: ' + path;
+            if (__1.tbConfig.logs.error)
+                console.error(error);
+            return res.status(404).json({ error });
+        }
+        let context = {};
+        for (const middleware of middlewares) {
+            if ((0, helpers_1.matchesPattern)(path, middleware.pattern)) {
+                const result = await middleware.handler(req, res);
+                if (result?.next === false)
+                    return;
+                if (result?.context)
+                    context = { ...context, ...result.context };
+            }
         }
-        res.json(await serverFunction(args, context));
+        res.json((await serverFunction(args, context)) || {});
     }
     catch (error) {
         if (Array.isArray(error.errors)) {
@@ -25,7 +123,7 @@ exports.default = (bridge, contextParser) => async (req, res) => {
             const errorMessage = (keyPath ? keyPath + ': ' : '') + error.errors[0].message;
             return res.status(400).send(errorMessage);
         }
-        if (config_1.config.logs.error)
+        if (__1.tbConfig.logs.error)
             console.error(error);
         return res.status(500).json({ error: error.message });
     }

package/dist/config/index.d.ts

@@ -4,9 +4,7 @@ interface config {
         response: boolean;
         error: boolean;
     };
-    idPrefix: string;
     responseDelay: number;
-    gracefulShutdown: boolean;
 }
 export declare const config: config;
 export {};

package/dist/config/index.js

@@ -7,7 +7,5 @@ exports.config = {
         response: true,
         error: true
     },
-    responseDelay: 0,
-    gracefulShutdown: false,
-    idPrefix: ''
+    responseDelay: 0
 };

package/dist/demo/bridge/index.d.ts

@@ -1,3 +1,4 @@
+import * as user from './user';
 declare const _default: {
     'user.fetch': (args: import("zod").TypeOf<import("zod").ZodObject<{
         id: import("zod").ZodNumber;
@@ -5,7 +6,9 @@ declare const _default: {
         id: number;
     }, {
         id: number;
-    }>>, context: import("zod").TypeOf<typeof import("./user/types").userContext>) => Promise<import("zod").TypeOf<import("zod").ZodObject<{
+    }>>, context: {
+        id: number;
+    }) => Promise<import("zod").TypeOf<import("zod").ZodObject<{
         id: import("zod").ZodNumber;
         name: import("zod").ZodString;
     }, "strip", import("zod").ZodTypeAny, {
@@ -15,5 +18,11 @@ declare const _default: {
         id: number;
         name: string;
     }>>>;
+    'user.update': (args: {
+        id: number;
+        name?: string;
+        email?: string;
+    }) => Promise<user.User>;
+    'user.fetchAll': () => Promise<user.User[]>;
 };
 export default _default;

package/dist/demo/bridge/index.js

@@ -35,5 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const user = __importStar(require("./user"));
 exports.default = {
-    'user.fetch': user.fetch
+    'user.fetch': user.fetch,
+    'user.update': user.update,
+    'user.fetchAll': user.fetchAll
 };

package/dist/demo/bridge/user/index.d.ts

@@ -1,3 +1,17 @@
 import { $z } from '@/index';
 import * as types from './types';
-export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: $z.infer<typeof types.userContext>) => Promise<$z.infer<typeof types.fetch.res>>;
+export interface User {
+    id: number;
+    name: string;
+    email: string;
+    createdAt: Date;
+}
+export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: {
+    id: number;
+}) => Promise<$z.infer<typeof types.fetch.res>>;
+export declare const update: (args: {
+    id: number;
+    name?: string;
+    email?: string;
+}) => Promise<User>;
+export declare const fetchAll: () => Promise<User[]>;

package/dist/demo/bridge/user/index.js

@@ -33,11 +33,36 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = void 0;
+exports.fetchAll = exports.update = exports.fetch = void 0;
 const types = __importStar(require("./types"));
+const users = [
+    { id: 1, name: 'Neil', email: 'neil@example.com', createdAt: new Date() },
+    { id: 2, name: 'John', email: 'john@example.com', createdAt: new Date() },
+    { id: 3, name: 'Jane', email: 'jane@example.com', createdAt: new Date() }
+];
 const fetch = async (args, context) => {
-    types.fetch.args.parse(args);
-    console.log('Context:', context);
-    return { id: args.id, name: 'Neil' };
+    args = types.fetch.args.parse(args);
+    console.log(context);
+    const user = users.find(user => user.id === args.id);
+    if (!user) {
+        throw new Error(`User with ID ${args.id} not found`);
+    }
+    return user;
 };
 exports.fetch = fetch;
+const update = async (args) => {
+    const user = users.find(user => user.id === args.id);
+    if (!user) {
+        throw new Error(`User with ID ${args.id} not found`);
+    }
+    if (args.name)
+        user.name = args.name;
+    if (args.email)
+        user.email = args.email;
+    return user;
+};
+exports.update = update;
+const fetchAll = async () => {
+    return users;
+};
+exports.fetchAll = fetchAll;

package/dist/demo/bridge/user/types.d.ts

@@ -1,16 +1,16 @@
-import { z } from 'zod';
+import { $z } from '@/index';
 export declare const fetch: {
-    args: z.ZodObject<{
-        id: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
+    args: $z.ZodObject<{
+        id: $z.ZodNumber;
+    }, "strip", $z.ZodTypeAny, {
         id: number;
     }, {
         id: number;
     }>;
-    res: z.ZodObject<{
-        id: z.ZodNumber;
-        name: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
+    res: $z.ZodObject<{
+        id: $z.ZodNumber;
+        name: $z.ZodString;
+    }, "strip", $z.ZodTypeAny, {
         id: number;
         name: string;
     }, {
@@ -18,9 +18,9 @@ export declare const fetch: {
         name: string;
     }>;
 };
-export declare const userContext: z.ZodObject<{
-    id: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
+export declare const userContext: $z.ZodObject<{
+    id: $z.ZodNumber;
+}, "strip", $z.ZodTypeAny, {
     id: number;
 }, {
     id: number;

package/dist/demo/bridge/user/types.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.userContext = exports.fetch = void 0;
-const zod_1 = require("zod");
+const index_1 = require("@/index");
 exports.fetch = {
-    args: zod_1.z.object({
-        id: zod_1.z.number()
+    args: index_1.$z.object({
+        id: index_1.$z.number().min(1)
     }),
-    res: zod_1.z.object({
-        id: zod_1.z.number(),
-        name: zod_1.z.string()
+    res: index_1.$z.object({
+        id: index_1.$z.number(),
+        name: index_1.$z.string()
     })
 };
-exports.userContext = zod_1.z.object({
-    id: zod_1.z.number()
+exports.userContext = index_1.$z.object({
+    id: index_1.$z.number()
 });

package/dist/demo/index.js

@@ -3,25 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("@/index");
+const __1 = require("..");
 const bridge_1 = __importDefault(require("./bridge"));
-index_1.tbConfig.logs.error = true;
-index_1.tbConfig.logs.request = true;
-index_1.tbConfig.logs.response = true;
-const app = (0, index_1.createApp)();
-(0, index_1.startServer)(app, 8080);
-const contextParser = async (req, res) => {
-    const headers = req.headers;
-    const bridge = req.originalUrl.split('/').pop();
-    if (bridge === 'test.error') {
-        res.sendStatus(400);
-        return { next: false };
-    }
-    return {
-        context: {
-            name: 'Typed Bridge',
-            authorization: headers.authorization || 'NO_AUTH'
-        }
-    };
-};
-app.use('/bridge', (0, index_1.createBridge)(bridge_1.default, contextParser));
+__1.tbConfig.logs.error = true;
+__1.tbConfig.logs.request = true;
+__1.tbConfig.logs.response = true;
+// tbConfig.responseDelay = 1000
+(0, __1.createBridge)(bridge_1.default, 8080, '/');

package/dist/helpers/index.d.ts

@@ -1,2 +1,3 @@
 export declare const printStartLogs: (port: number) => void;
 export declare const printStopLogs: () => void;
+export declare const matchesPattern: (str: string, pattern: string) => boolean;

package/dist/helpers/index.js

@@ -3,21 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printStopLogs = exports.printStartLogs = void 0;
+exports.matchesPattern = exports.printStopLogs = exports.printStartLogs = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const os_1 = __importDefault(require("os"));
-const __1 = require("..");
 const getLocalIPList = () => {
-    const ipList = Object.values(os_1.default.networkInterfaces())
-        .map(x => (x && x[0] ? x[0].address : null))
-        .filter(ip => /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/.test(ip || ''));
-    if (ipList.includes('127.0.0.1'))
+    const interfaces = os_1.default.networkInterfaces();
+    const ipList = [];
+    Object.values(interfaces).forEach(ifaceArr => {
+        ifaceArr?.forEach(iface => {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                ipList.push(iface.address);
+            }
+        });
+    });
+    // Always include localhost for convenience
+    if (!ipList.includes('127.0.0.1'))
+        ipList.unshift('localhost');
+    else
         ipList.unshift('localhost');
     return ipList;
 };
 const seperator = '\n-x-x-x-x-x-\n';
 const printStartLogs = (port) => {
     const ipList = getLocalIPList();
+    console.log(ipList);
     console.log(seperator);
     console.log(chalk_1.default.bgWhite.black('  Typed Bridge  '));
     console.log(seperator);
@@ -28,7 +37,15 @@ const printStartLogs = (port) => {
 exports.printStartLogs = printStartLogs;
 const printStopLogs = () => {
     console.log(seperator);
-    console.log(chalk_1.default.red(`Server${__1.tbConfig.gracefulShutdown ? ' gracefully ' : ' '}stopped at: ` + new Date().toISOString()));
+    console.log(chalk_1.default.red(`Server stopped at: ` + new Date().toISOString()));
     console.log(seperator);
 };
 exports.printStopLogs = printStopLogs;
+const matchesPattern = (str, pattern) => {
+    // Escape regex special chars except "*"
+    const escaped = pattern.replace(/[-\\^$+?.()|[\]{}]/g, '\\$&');
+    // Replace "*" with ".*" for wildcard matching
+    const regexStr = '^' + escaped.replace(/\*/g, '.*') + '$';
+    return new RegExp(regexStr).test(str);
+};
+exports.matchesPattern = matchesPattern;

package/dist/index.d.ts

@@ -1,7 +1,5 @@
 import 'dotenv/config';
-export { default as createApp } from './app';
-export { default as createBridge } from './bridge';
+export { createBridge, createMiddleware, onShutdown } from './bridge';
 export { config as tbConfig } from './config';
-export { default as startServer } from './server';
 export { default as $z } from 'zod';
 export { Application, default as express, NextFunction, Request, Response, Router } from 'express';

package/dist/index.js

@@ -3,16 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = exports.express = exports.$z = exports.startServer = exports.tbConfig = exports.createBridge = exports.createApp = void 0;
+exports.Router = exports.express = exports.$z = exports.tbConfig = exports.onShutdown = exports.createMiddleware = exports.createBridge = void 0;
 require("dotenv/config");
-var app_1 = require("./app");
-Object.defineProperty(exports, "createApp", { enumerable: true, get: function () { return __importDefault(app_1).default; } });
 var bridge_1 = require("./bridge");
-Object.defineProperty(exports, "createBridge", { enumerable: true, get: function () { return __importDefault(bridge_1).default; } });
+Object.defineProperty(exports, "createBridge", { enumerable: true, get: function () { return bridge_1.createBridge; } });
+Object.defineProperty(exports, "createMiddleware", { enumerable: true, get: function () { return bridge_1.createMiddleware; } });
+Object.defineProperty(exports, "onShutdown", { enumerable: true, get: function () { return bridge_1.onShutdown; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "tbConfig", { enumerable: true, get: function () { return config_1.config; } });
-var server_1 = require("./server");
-Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return __importDefault(server_1).default; } });
 var zod_1 = require("zod");
 Object.defineProperty(exports, "$z", { enumerable: true, get: function () { return __importDefault(zod_1).default; } });
 var express_1 = require("express");

package/dist/scripts/cli.js

@@ -8,7 +8,7 @@ const commander_1 = require("commander");
 const buildTypeBridge_1 = __importDefault(require("./buildTypeBridge"));
 const typedBridgeCleaner_1 = __importDefault(require("./typedBridgeCleaner"));
 commander_1.program
-    .command('gen-typed-bridge')
+    .command('gen-typed-bridge-client')
     .description('Generate a typed bridge')
     .option('--src <string>', 'Set typed bridge source file path')
     .option('--dest <string>', 'Set typed bridge destination file path', 'typedBridge.ts')
@@ -20,5 +20,6 @@ commander_1.program
         throw new Error('--dest required');
     await (0, buildTypeBridge_1.default)(src, dest);
     (0, typedBridgeCleaner_1.default)(dest);
+    console.log('\n✅ Bridge generated successfully!\n');
 });
 commander_1.program.parse();