@carlos-tzin/tzin 0.1.5 → 0.1.7

package/dist/cli.js

@@ -8,6 +8,8 @@ function usage() {
 
   Commands:
     tzin dev [entry] [--port N]     start dev server with hot reload
+    tzin build                      build for production
+    tzin deploy [--target <target>] deploy (node, workers)
     tzin generate route <name>      generate a route stub
     tzin generate middleware <name>  generate a middleware stub
     tzin generate test <name>       generate a test stub`);
@@ -35,6 +37,66 @@ if (cmd === 'dev') {
     child.on('exit', (code) => process.exit(code ?? 0));
     process.exit(0);
 }
+// ── build ─────────────────────────────────────────────────────────────
+if (cmd === 'build') {
+    const cwd = process.cwd();
+    // Check for tsconfig
+    if (!existsSync(resolve(cwd, 'tsconfig.json'))) {
+        console.error('No tsconfig.json found');
+        process.exit(1);
+    }
+    // Check for src/app.ts
+    if (!existsSync(resolve(cwd, 'src/app.ts'))) {
+        console.error('No src/app.ts found. Create an app first.');
+        process.exit(1);
+    }
+    console.log('Building...');
+    const child = spawn('npx', ['tsc', '-p', 'tsconfig.json'], {
+        cwd,
+        stdio: 'inherit',
+    });
+    child.on('exit', (code) => {
+        if (code === 0) {
+            console.log('\n✓ Build complete → dist/');
+        }
+        process.exit(code ?? 1);
+    });
+    process.exit(0);
+}
+// ── deploy ────────────────────────────────────────────────────────────
+if (cmd === 'deploy') {
+    const cwd = process.cwd();
+    const targetFlag = rest.indexOf('--target');
+    const target = targetFlag !== -1 ? rest[targetFlag + 1] : 'node';
+    if (target === 'workers') {
+        console.log('Deploying to Cloudflare Workers...');
+        // Check for wrangler.toml
+        if (!existsSync(resolve(cwd, 'wrangler.toml'))) {
+            console.error('No wrangler.toml found. Run: npx wrangler init');
+            process.exit(1);
+        }
+        const child = spawn('npx', ['wrangler', 'deploy'], {
+            cwd,
+            stdio: 'inherit',
+        });
+        child.on('exit', (code) => process.exit(code ?? 1));
+        process.exit(0);
+    }
+    // Default: Node
+    console.log('Building for production...');
+    const build = spawn('npx', ['tsc', '-p', 'tsconfig.json'], {
+        cwd,
+        stdio: 'inherit',
+    });
+    build.on('exit', (code) => {
+        if (code !== 0)
+            process.exit(code ?? 1);
+        console.log('\n✓ Build complete');
+        console.log('Run: node dist/index.js');
+        process.exit(0);
+    });
+    process.exit(0);
+}
 // ── generate ─────────────────────────────────────────────────────────
 if (cmd === 'generate' || cmd === 'g') {
     const [sub, ...args] = rest;

package/dist/db.d.ts

@@ -0,0 +1,96 @@
+import type { TSchema } from '@sinclair/typebox';
+export type SchemaToType<S> = S extends TSchema ? ReturnType<S['Decode']> : never;
+export interface ModelConfig {
+    /** Primary key field (default: 'id') */
+    primaryKey?: string;
+}
+export interface QueryBuilder<T> {
+    /** Filter by field equality */
+    where(field: keyof T, value: T[keyof T]): QueryBuilder<T>;
+    /** Filter by field inequality */
+    whereNot(field: keyof T, value: T[keyof T]): QueryBuilder<T>;
+    /** Filter with greater than */
+    whereGt(field: keyof T, value: number): QueryBuilder<T>;
+    /** Filter with less than */
+    whereLt(field: keyof T, value: number): QueryBuilder<T>;
+    /** Limit results */
+    limit(n: number): QueryBuilder<T>;
+    /** Offset results */
+    offset(n: number): QueryBuilder<T>;
+    /** Order by field */
+    orderBy(field: keyof T, direction?: 'asc' | 'desc'): QueryBuilder<T>;
+    /** Select specific fields */
+    select<K extends keyof T>(...fields: K[]): QueryBuilder<Pick<T, K>>;
+    /** Execute query and return results */
+    exec(): Promise<T[]>;
+    /** Execute query and return first result */
+    first(): Promise<T | null>;
+    /** Count results */
+    count(): Promise<number>;
+}
+export interface Model<T, S extends TSchema> {
+    /** Find by primary key */
+    findById(id: string): Promise<T | null>;
+    /** Find first matching record */
+    findFirst(where: Partial<T>): Promise<T | null>;
+    /** Find many matching records */
+    findMany(where?: Partial<T>): QueryBuilder<T>;
+    /** Create a new record */
+    create(data: T): Promise<T>;
+    /** Create many records */
+    createMany(data: T[]): Promise<T[]>;
+    /** Update by primary key */
+    update(id: string, data: Partial<T>): Promise<T | null>;
+    /** Delete by primary key */
+    delete(id: string): Promise<boolean>;
+    /** Delete many matching records */
+    deleteMany(where: Partial<T>): Promise<number>;
+    /** Count records */
+    count(where?: Partial<T>): Promise<number>;
+    /** Execute raw query */
+    raw(sql: string, ...args: unknown[]): Promise<T[]>;
+    /** Schema validation */
+    readonly schema: S;
+    /** Table name */
+    readonly tableName: string;
+}
+export interface Store {
+    findAll(table: string): Record<string, unknown>[];
+    findById(table: string, id: string, pk: string): Record<string, unknown> | null;
+    insert(table: string, data: Record<string, unknown>): Record<string, unknown>;
+    update(table: string, id: string, data: Record<string, unknown>, pk: string): Record<string, unknown> | null;
+    delete(table: string, id: string, pk: string): boolean;
+    deleteWhere(table: string, where: Record<string, unknown>, pk: string): number;
+    count(table: string, where?: Record<string, unknown>): number;
+    query(table: string, filters: Filter[]): Record<string, unknown>[];
+}
+interface Filter {
+    field: string;
+    op: '=' | '!=' | '>' | '<';
+    value: unknown;
+}
+/** Set a custom store adapter (e.g., for SQL databases) */
+export declare function setStore(store: Store): void;
+/** Get the current store (useful for testing) */
+export declare function getStore(): Store;
+/** Reset the store (useful for testing) */
+export declare function resetStore(): void;
+/**
+ * Define a typed database model.
+ *
+ * @example
+ * ```ts
+ * import { defineModel } from '@carlos-tzin/tzin/db'
+ * import { t } from '@carlos-tzin/tzin'
+ *
+ * const User = defineModel('users', t.Object({
+ *   id: t.String(),
+ *   name: t.String(),
+ *   email: t.String(),
+ * }))
+ *
+ * const user = await User.findById('1')
+ * ```
+ */
+export declare function defineModel<S extends TSchema>(tableName: string, schema: S, config?: ModelConfig): Model<SchemaToType<S>, S>;
+export {};

package/dist/db.js

@@ -0,0 +1,212 @@
+// ── Memory store (default) ──────────────────────────────────────────
+class MemoryStore {
+    data = new Map();
+    table(table) {
+        if (!this.data.has(table))
+            this.data.set(table, []);
+        return this.data.get(table);
+    }
+    findAll(table) {
+        return [...this.table(table)];
+    }
+    findById(table, id, pk) {
+        return this.table(table).find((r) => r[pk] === id) ?? null;
+    }
+    insert(table, data) {
+        this.table(table).push({ ...data });
+        return data;
+    }
+    update(table, id, data, pk) {
+        const row = this.table(table).find((r) => r[pk] === id);
+        if (!row)
+            return null;
+        Object.assign(row, data);
+        return { ...row };
+    }
+    delete(table, id, pk) {
+        const rows = this.table(table);
+        const idx = rows.findIndex((r) => r[pk] === id);
+        if (idx === -1)
+            return false;
+        rows.splice(idx, 1);
+        return true;
+    }
+    deleteWhere(table, where, pk) {
+        const rows = this.table(table);
+        const before = rows.length;
+        this.data.set(table, rows.filter((r) => !Object.entries(where).every(([k, v]) => r[k] === v)));
+        return before - this.data.get(table).length;
+    }
+    count(table, where) {
+        if (!where)
+            return this.table(table).length;
+        return this.table(table).filter((r) => Object.entries(where).every(([k, v]) => r[k] === v)).length;
+    }
+    query(table, filters) {
+        return this.table(table).filter((row) => filters.every((f) => {
+            const val = row[f.field];
+            if (f.op === '=')
+                return val === f.value;
+            if (f.op === '!=')
+                return val !== f.value;
+            if (f.op === '>')
+                return val > f.value;
+            if (f.op === '<')
+                return val < f.value;
+            return true;
+        }));
+    }
+}
+// ── Global store ─────────────────────────────────────────────────────
+let globalStore = new MemoryStore();
+/** Set a custom store adapter (e.g., for SQL databases) */
+export function setStore(store) {
+    globalStore = store;
+}
+/** Get the current store (useful for testing) */
+export function getStore() {
+    return globalStore;
+}
+/** Reset the store (useful for testing) */
+export function resetStore() {
+    globalStore = new MemoryStore();
+}
+// ── defineModel ──────────────────────────────────────────────────────
+/**
+ * Define a typed database model.
+ *
+ * @example
+ * ```ts
+ * import { defineModel } from '@carlos-tzin/tzin/db'
+ * import { t } from '@carlos-tzin/tzin'
+ *
+ * const User = defineModel('users', t.Object({
+ *   id: t.String(),
+ *   name: t.String(),
+ *   email: t.String(),
+ * }))
+ *
+ * const user = await User.findById('1')
+ * ```
+ */
+export function defineModel(tableName, schema, config) {
+    const pk = config?.primaryKey ?? 'id';
+    function applyFilters(rows, filters) {
+        return globalStore.query(tableName, filters);
+    }
+    return {
+        schema,
+        tableName,
+        async findById(id) {
+            const row = globalStore.findById(tableName, id, pk);
+            return row ? schema.Decode(row) : null;
+        },
+        async findFirst(where) {
+            const rows = globalStore.findAll(tableName).filter((r) => Object.entries(where).every(([k, v]) => r[k] === v));
+            return rows[0] ? schema.Decode(rows[0]) : null;
+        },
+        findMany(where) {
+            const filters = where
+                ? Object.entries(where).map(([field, value]) => ({ field, op: '=', value }))
+                : [];
+            const builder = {
+                where(field, value) {
+                    filters.push({ field: field, op: '=', value });
+                    return builder;
+                },
+                whereNot(field, value) {
+                    filters.push({ field: field, op: '!=', value });
+                    return builder;
+                },
+                whereGt(field, value) {
+                    filters.push({ field: field, op: '>', value });
+                    return builder;
+                },
+                whereLt(field, value) {
+                    filters.push({ field: field, op: '<', value });
+                    return builder;
+                },
+                limit: (n) => {
+                    // Store limit for later
+                    const origExec = builder.exec;
+                    builder.exec = async () => {
+                        const rows = await origExec();
+                        return rows.slice(0, n);
+                    };
+                    return builder;
+                },
+                offset: (n) => {
+                    const origExec = builder.exec;
+                    builder.exec = async () => {
+                        const rows = await origExec();
+                        return rows.slice(n);
+                    };
+                    return builder;
+                },
+                orderBy: (field, direction = 'asc') => {
+                    const origExec = builder.exec;
+                    builder.exec = async () => {
+                        const rows = await origExec();
+                        return rows.sort((a, b) => {
+                            const av = a[field];
+                            const bv = b[field];
+                            return direction === 'asc' ? (av > bv ? 1 : -1) : (av < bv ? 1 : -1);
+                        });
+                    };
+                    return builder;
+                },
+                select: (...fields) => {
+                    const origExec = builder.exec;
+                    builder.exec = async () => {
+                        const rows = await origExec();
+                        return rows.map((r) => {
+                            const obj = {};
+                            for (const f of fields)
+                                obj[f] = r[f];
+                            return obj;
+                        });
+                    };
+                    return builder;
+                },
+                exec: async () => {
+                    const rows = applyFilters([], filters);
+                    return rows.map((r) => schema.Decode(r));
+                },
+                first: async () => {
+                    const rows = await builder.exec();
+                    return rows[0] ?? null;
+                },
+                count: async () => {
+                    return globalStore.count(tableName, where);
+                },
+            };
+            return builder;
+        },
+        async create(data) {
+            const row = globalStore.insert(tableName, data);
+            return schema.Decode(row);
+        },
+        async createMany(data) {
+            return Promise.all(data.map((d) => this.create(d)));
+        },
+        async update(id, data) {
+            const row = globalStore.update(tableName, id, data, pk);
+            return row ? schema.Decode(row) : null;
+        },
+        async delete(id) {
+            return globalStore.delete(tableName, id, pk);
+        },
+        async deleteMany(where) {
+            return globalStore.deleteWhere(tableName, where, pk);
+        },
+        async count(where) {
+            return globalStore.count(tableName, where);
+        },
+        async raw(sql, ...args) {
+            // For in-memory store, this is a no-op
+            // Real DB adapters would implement this
+            console.warn('raw() not supported with in-memory store');
+            return [];
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carlos-tzin/tzin",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Contract-first TypeScript framework. Types that scale, realtime channels with presence, and an MCP server for every API.",
   "license": "MIT",
   "author": "The tzin authors",
@@ -46,6 +46,10 @@
     "./test": {
       "types": "./dist/test.d.ts",
       "default": "./dist/test.js"
+    },
+    "./db": {
+      "types": "./dist/db.d.ts",
+      "default": "./dist/db.js"
     }
   },
   "files": [