@aurios/mizzling 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# mizzling
+
+## 1.0.2
+
+### Patch Changes
+
+- Updated dependencies
+  - @mizzle/shared@0.0.1
+
+## 1.0.1
+
+### Patch Changes
+
+- fix: resolve schema discovery issues in monorepos and stabilize test suite.
+
+## 1.0.0
+
+### Major Changes
+
+- Initial production release of Mizzle ORM and Mizzling CLI.
+  Includes:
+  - Fluent Query Builder (Select, Insert, Update, Delete)
+  - Native Date Support with ISO 8601 storage
+  - Relational Queries with Single-Table optimization
+  - Atomic Transactions support
+  - Migration CLI with schema discovery and push/pull
+  - High-performance tsup-based bundling

package/dist/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import{Command as He}from"commander";import*as b from"@clack/prompts";import{join as X}from"path";import{existsSync as Q}from"fs";import{DynamoDBClient as ee}from"@aws-sdk/client-dynamodb";import{fromIni as te}from"@aws-sdk/credential-provider-ini";import{NodeHttpHandler as ne}from"@smithy/node-http-handler";import oe from"http";import ae from"https";function h(e){let n={keepAlive:!0,maxSockets:1/0},t={region:e.region||"us-east-1",endpoint:e.endpoint,maxAttempts:e.maxAttempts,requestHandler:new ne({httpAgent:new oe.Agent(n),httpsAgent:new ae.Agent(n)})};return e.credentials?t.credentials=e.credentials:e.profile?t.credentials=te({profile:e.profile}):e.endpoint&&(e.endpoint.includes("localhost")||e.endpoint.includes("127.0.0.1"))&&(t.credentials={accessKeyId:"local",secretAccessKey:"local"}),new ee(t)}async function N(e="mizzle.config.ts"){let t=process.env.MIZZLE_CONFIG||X(process.cwd(),e);if(!Q(t))throw new Error(`Could not find ${e} in current directory.`);try{let o=await import(t),a=o.default||o;if(!a||typeof a!="object")throw new Error("Invalid config: default export must be an object");if(!a.schema)throw new Error("Invalid config: missing 'schema' path");if(!a.out)throw new Error("Invalid config: missing 'out' directory");let i={...a};return process.env.MIZZLE_REGION&&(i.region=process.env.MIZZLE_REGION),process.env.MIZZLE_ENDPOINT&&(i.endpoint=process.env.MIZZLE_ENDPOINT),process.env.MIZZLE_SCHEMA&&(i.schema=process.env.MIZZLE_SCHEMA),process.env.MIZZLE_OUT&&(i.out=process.env.MIZZLE_OUT),i}catch(o){if(o instanceof Error&&o.message.startsWith("Invalid config"))throw o;let a=o instanceof Error?o.message:String(o);throw new Error(`Failed to load config: ${a}`)}}var f={COLUMNS:Symbol.for("mizzle:Columns"),INDEXES:Symbol.for("mizzle:Indexes"),SORT_KEY:Symbol.for("mizzle:SortKey"),TABLE_NAME:Symbol.for("mizzle:TableName"),PARTITION_KEY:Symbol.for("mizzle:PartitionKey")},u={ENTITY_NAME:Symbol.for("mizzle:EntityName"),ENTITY_STRATEGY:Symbol.for("mizzle:EntityStrategy"),PHYSICAL_TABLE:Symbol.for("mizzle:PhysicalTable"),COLUMNS:Symbol.for("mizzle:Columns"),ENTITY_KIND:Symbol.for("mizzle:EntityKind")};var v=class{[f.TABLE_NAME]="";[f.INDEXES]=void 0;[f.PARTITION_KEY]={};[f.SORT_KEY]=void 0;static Symbol=f;constructor(e,n){this[f.TABLE_NAME]=e,this[f.PARTITION_KEY]=n.pk.build(this),this[f.SORT_KEY]=n.sk?n.sk.build(this):void 0,this[f.INDEXES]=n.indexes}},O=class{[u.ENTITY_NAME]="";[u.PHYSICAL_TABLE]={};[u.COLUMNS]={};[u.ENTITY_STRATEGY]={};static Symbol=u;constructor(e,n,t,o){this[u.ENTITY_NAME]=e,this[u.PHYSICAL_TABLE]=n,this[u.COLUMNS]=t,this[u.ENTITY_STRATEGY]=o}};var M={COLUMNS:Symbol.for("mizzle:Columns"),INDEXES:Symbol.for("mizzle:Indexes"),SORT_KEY:Symbol.for("mizzle:SortKey"),TABLE_NAME:Symbol.for("mizzle:TableName"),PARTITION_KEY:Symbol.for("mizzle:PartitionKey")},_={ENTITY_NAME:Symbol.for("mizzle:EntityName"),ENTITY_STRATEGY:Symbol.for("mizzle:EntityStrategy"),PHYSICAL_TABLE:Symbol.for("mizzle:PhysicalTable"),COLUMNS:Symbol.for("mizzle:Columns"),ENTITY_KIND:Symbol.for("mizzle:EntityKind")};import ie from"fast-glob";import{stat as re}from"fs/promises";import{resolve as se}from"path";async function w(e){let n=Array.isArray(e.schema)?e.schema:[e.schema],t=[],o=[],a=new Set,i=async r=>{let s=se(process.cwd(),r);if(!a.has(s)){a.add(s);try{let l=await import(s);for(let m in l){let c=l[m];!c||typeof c!="object"||(c instanceof v||c[M.TABLE_NAME]!==void 0?t.push(c):(c instanceof O||c[_.ENTITY_NAME]!==void 0)&&o.push(c))}}catch(l){console.warn(`Failed to import schema file: ${s}`,l)}}};for(let r of n){let s=r,l=!1;try{let c=await re(r);c.isDirectory()?s=`${r}/**/*.{ts,js,tsx,jsx}`:c.isFile()&&(l=!0)}catch{}if(l){await i(r);continue}let m=await ie(s,{absolute:!0});for(let c of m)await i(c)}return{tables:t,entities:o}}import{join as $}from"path";import{writeFile as le,readFile as ce,mkdir as me,readdir as fe}from"fs/promises";import{existsSync as k}from"fs";var j="snapshot.json";async function P(e,n){k(e)||await me(e,{recursive:!0});let t=$(e,j);await le(t,JSON.stringify(n,null,2),"utf-8")}async function Y(e){let n=$(e,j);if(!k(n))return null;let t=await ce(n,"utf-8");return JSON.parse(t)}function E(e){let n={};for(let t of e.tables){let o=e.entities.filter(i=>i[u.PHYSICAL_TABLE]===t),a=pe(t,o);n[a.TableName]=a}return{version:"1",tables:n}}async function R(e){if(!k(e))return"0000";let n=await fe(e),t=-1;for(let o of n){if(!o.endsWith(".ts"))continue;let a=o.match(/^(\d{4})_/);if(a){let i=parseInt(a[1],10);i>t&&(t=i)}}return t===-1?"0000":(t+1).toString().padStart(4,"0")}function pe(e,n){let t=e[f.TABLE_NAME],o=new Map,a=e[f.PARTITION_KEY];o.set(a.name,a.getDynamoType());let i=e[f.SORT_KEY];i&&o.set(i.name,i.getDynamoType());let r=[{AttributeName:a.name,KeyType:"HASH"}];i&&r.push({AttributeName:i.name,KeyType:"RANGE"});let s=[],l=[],m=e[f.INDEXES]||{};for(let[d,y]of Object.entries(m)){let B=y.type,p=y.config;if(B==="gsi"){if(p.pk){let T=K(p.pk,e,n);o.set(p.pk,T)}if(p.sk){let T=K(p.sk,e,n);o.set(p.sk,T)}let x={IndexName:d,KeySchema:[{AttributeName:p.pk,KeyType:"HASH"}],Projection:{ProjectionType:"ALL"}};p.sk&&x.KeySchema.push({AttributeName:p.sk,KeyType:"RANGE"}),s.push(x)}else if(B==="lsi"){if(p.sk){let T=K(p.sk,e,n);o.set(p.sk,T)}let x={IndexName:d,KeySchema:[{AttributeName:a.name,KeyType:"HASH"},{AttributeName:p.sk,KeyType:"RANGE"}],Projection:{ProjectionType:"ALL"}};l.push(x)}}let c=Array.from(o.entries()).map(([d,y])=>({AttributeName:d,AttributeType:y})).sort((d,y)=>d.AttributeName.localeCompare(y.AttributeName));s.sort((d,y)=>(d.IndexName||"").localeCompare(y.IndexName||"")),l.sort((d,y)=>(d.IndexName||"").localeCompare(y.IndexName||""));let S={TableName:t,AttributeDefinitions:c,KeySchema:r};return s.length>0&&(S.GlobalSecondaryIndexes=s),l.length>0&&(S.LocalSecondaryIndexes=l),S}function K(e,n,t){let o=n[f.PARTITION_KEY];if(o.name===e)return o.getDynamoType();let a=n[f.SORT_KEY];if(a&&a.name===e)return a.getDynamoType();for(let i of t){let r=i[u.COLUMNS];if(r){let s=r[e];if(s)return s.getDynamoType()}}throw new Error(`Could not resolve type for column '${e}' in table '${n[f.TABLE_NAME]}'. Ensure it is defined in an Entity.`)}function I(e,n){let t=[],o=E(e).tables,a=n.tables||{},i=new Set([...Object.keys(o),...Object.keys(a)]);for(let r of i){let s=o[r],l=a[r];s&&!l?t.push({type:"create",table:s}):!s&&l?t.push({type:"delete",tableName:r}):s&&l&&(ue(s,l)||t.push({type:"update",tableName:r,changes:["Changed"]}))}return t}function ue(e,n){let t=o=>{let a={...o};return a.AttributeDefinitions=[...a.AttributeDefinitions||[]].sort((i,r)=>(i.AttributeName||"").localeCompare(r.AttributeName||"")),a.GlobalSecondaryIndexes&&(a.GlobalSecondaryIndexes=[...a.GlobalSecondaryIndexes].sort((i,r)=>(i.IndexName||"").localeCompare(r.IndexName||""))),a.LocalSecondaryIndexes&&(a.LocalSecondaryIndexes=[...a.LocalSecondaryIndexes].sort((i,r)=>(i.IndexName||"").localeCompare(r.IndexName||""))),a};return JSON.stringify(t(e))===JSON.stringify(t(n))}import{join as de}from"path";import{writeFile as ye,mkdir as ge}from"fs/promises";import{existsSync as he}from"fs";import{text as be,isCancel as Se,cancel as Te,intro as Ne,outro as U}from"@clack/prompts";async function F(e){Ne("Mizzle Generate");let{config:n}=e,t=e.discoverSchema||w;try{let o=await t(n),a=n.out,i=await Y(a)||{version:"0",tables:{}},r=E(o),s=I(o,i);if(s.length===0){U("No changes detected.");return}console.log(`Detected ${s.length} changes.`);let l=await R(a),m=e.name;if(m||(m=await be({message:"Enter migration name",placeholder:"init",initialValue:"migration",validate(y){if(y.length===0)return"Name is required"}})),Se(m)){Te("Operation cancelled.");return}let c=`${l}_${m}.ts`;he(a)||await ge(a,{recursive:!0});let S=de(a,c),d=Ee(s);await ye(S,d),console.log(`Created migration: ${c}`),await P(a,r),U("Updated snapshot.json")}catch(o){console.error("Error generating migration:",o),process.exit(1)}}function Ee(e){let n=[],t=[];for(let o of e)o.type==="create"?(n.push(`// Create Table: ${o.table.TableName}`),n.push(`await db.createTable("${o.table.TableName}", ${JSON.stringify(o.table,null,2)});
+`),t.unshift(`// Drop Table: ${o.table.TableName}`),t.unshift(`await db.deleteTable("${o.table.TableName}");
+`)):o.type==="delete"?(n.push(`// Drop Table: ${o.tableName}`),n.push(`await db.deleteTable("${o.tableName}");
+`),t.unshift(`// Create Table: ${o.tableName}`),t.unshift(`// TODO: Restore table definition for rollback
+`)):o.type==="update"&&(n.push(`// Update Table: ${o.tableName}`),t.unshift(`// Revert Update Table: ${o.tableName}`));return`import { Mizzle } from "@auri/mizzle";
+
+export async function up(db: Mizzle) {
+    ${n.join("    ")}
+}
+
+export async function down(db: Mizzle) {
+    ${t.join("    ")}
+}
+`}import{existsSync as xe,writeFileSync as we}from"fs";import{join as Ie}from"path";import{intro as Ae,outro as Ce,text as A,isCancel as C,cancel as z}from"@clack/prompts";async function G(){let e=Ie(process.cwd(),"mizzle.config.ts");if(xe(e)){console.log("mizzle.config.ts already exists in the current directory. Aborting.");return}Ae("Mizzle Initialization");let n=await A({message:"Where is your schema file or directory located?",placeholder:"./src/schema.ts",initialValue:"./src/schema.ts",validate:r=>{if(!r)return"Schema path is required"}});if(C(n)){z("Operation cancelled.");return}let t=await A({message:"Where should Mizzle store migrations and snapshots?",placeholder:"./migrations",initialValue:"./migrations",validate:r=>{if(!r)return"Output directory is required"}});if(C(t)){z("Operation cancelled.");return}let o=await A({message:"Which AWS region do you want to use?",placeholder:"us-east-1",initialValue:"us-east-1"});if(C(o)){z("Operation cancelled.");return}let a=await A({message:"Do you want to use a custom endpoint (e.g., for local development)?",placeholder:"http://localhost:8000 (optional)"});if(C(a)){z("Operation cancelled.");return}let i=`import { defineConfig } from "@auri/mizzle";
+
+export default defineConfig({
+  schema: "${n}",
+  out: "${t}",
+  region: "${o}",
+  ${a?`endpoint: "${a}",`:'// endpoint: "http://localhost:8000",'}
+});
+`;we(e,i),Ce("mizzle.config.ts created successfully!")}import{ListTablesCommand as ze,DescribeTableCommand as De}from"@aws-sdk/client-dynamodb";async function D(e){let n={},t,o=[];do{let a=await e.send(new ze({ExclusiveStartTableName:t}));a.TableNames&&o.push(...a.TableNames),t=a.LastEvaluatedTableName}while(t);for(let a of o)try{let i=await e.send(new De({TableName:a}));if(i.Table){let r=Le(i.Table);n[a]=r}}catch(i){console.warn(`Failed to describe table ${a}:`,i)}return{version:"remote",tables:n}}function Le(e){let n={TableName:e.TableName,AttributeDefinitions:e.AttributeDefinitions?.map(t=>({AttributeName:t.AttributeName,AttributeType:t.AttributeType})).sort((t,o)=>t.AttributeName.localeCompare(o.AttributeName))||[],KeySchema:e.KeySchema?.map(t=>({AttributeName:t.AttributeName,KeyType:t.KeyType}))||[]};return e.GlobalSecondaryIndexes&&e.GlobalSecondaryIndexes.length>0&&(n.GlobalSecondaryIndexes=e.GlobalSecondaryIndexes.map(t=>({IndexName:t.IndexName,KeySchema:t.KeySchema?.map(o=>({AttributeName:o.AttributeName,KeyType:o.KeyType})),Projection:t.Projection?{ProjectionType:t.Projection.ProjectionType}:void 0})).sort((t,o)=>t.IndexName.localeCompare(o.IndexName))),e.LocalSecondaryIndexes&&e.LocalSecondaryIndexes.length>0&&(n.LocalSecondaryIndexes=e.LocalSecondaryIndexes.map(t=>({IndexName:t.IndexName,KeySchema:t.KeySchema?.map(o=>({AttributeName:o.AttributeName,KeyType:o.KeyType})),Projection:t.Projection?{ProjectionType:t.Projection.ProjectionType}:void 0})).sort((t,o)=>t.IndexName.localeCompare(o.IndexName))),n}import{CreateTableCommand as ve}from"@aws-sdk/client-dynamodb";import{confirm as Oe,isCancel as Me,cancel as _e,intro as Ke,outro as H,spinner as ke}from"@clack/prompts";async function Z(e){Ke("Mizzle Push");let{config:n,force:t}=e,o=e.discoverSchema||w,a=e.client||h(n);try{let i=await o(n),r=await D(a),s=I(i,r);if(s.length===0){H("Remote is up to date.");return}console.log(`Pushing ${s.length} changes to remote...`);let l=t;if(l||(l=await Oe({message:"Do you want to apply these changes?"})),Me(l)||!l){_e("Operation cancelled.");return}let m=ke();m.start("Pushing changes...");for(let c of s)c.type==="create"?(m.message(`Creating table: ${c.table.TableName}`),await a.send(new ve({TableName:c.table.TableName,AttributeDefinitions:c.table.AttributeDefinitions,KeySchema:c.table.KeySchema,GlobalSecondaryIndexes:c.table.GlobalSecondaryIndexes,LocalSecondaryIndexes:c.table.LocalSecondaryIndexes,BillingMode:"PAY_PER_REQUEST"}))):c.type==="delete"?console.log(`Untracked table found: ${c.tableName} (Skipping deletion)`):c.type==="update"&&m.message(`Updating table: ${c.tableName} (Not fully implemented)`);m.stop("Push complete."),H("Done")}catch(i){console.error("Error pushing changes:",i),process.exit(1)}}import"@aws-sdk/client-dynamodb";import{intro as Pe,outro as V,spinner as Ye}from"@clack/prompts";async function W(e){Pe("Mizzle List Tables");let n=e.client||h(e.config),t=Ye();t.start("Fetching remote tables...");try{let o=await D(n);t.stop("Fetched remote tables.");let a=Object.values(o.tables);if(a.length===0){console.log("No tables found in the remote environment."),V("Done");return}console.log(`Found ${a.length} tables:`);for(let i of a){console.log(`- ${i.TableName}`);let r=i.KeySchema.find(l=>l.KeyType==="HASH")?.AttributeName,s=i.KeySchema.find(l=>l.KeyType==="RANGE")?.AttributeName;console.log(`  PK: ${r}, SK: ${s||"(none)"}`),i.GlobalSecondaryIndexes&&i.GlobalSecondaryIndexes.length>0&&console.log(`  GSIs: ${i.GlobalSecondaryIndexes.map(l=>l.IndexName).join(", ")}`)}V("Done")}catch(o){t.stop("Failed to fetch tables."),console.error("Error listing tables:",o),process.exit(1)}}import{ListTablesCommand as Re,DeleteTableCommand as Be}from"@aws-sdk/client-dynamodb";import{intro as $e,outro as L,multiselect as je,confirm as Ue,isCancel as q,cancel as Fe,spinner as Ge}from"@clack/prompts";async function J(e){$e("Mizzle Drop Tables");let n=e.client||h(e.config);try{let t=new Re({}),a=(await n.send(t)).TableNames||[];if(a.length===0){console.log("No tables found in the remote environment."),L("Done");return}let i=await je({message:"Select tables to DELETE (This action is irreversible!)",options:a.map(m=>({value:m,label:m}))});if(q(i)){Fe("Operation cancelled.");return}let r=i;if(r.length===0){console.log("No tables selected."),L("Done");return}let s=await Ue({message:`Are you SURE you want to delete ${r.length} table(s)?`});if(q(s)||!s){console.log("Operation cancelled."),L("Done");return}let l=Ge();l.start("Deleting tables...");for(let m of r)l.message(`Deleting ${m}...`),await n.send(new Be({TableName:m}));l.stop("All selected tables deleted."),L("Done")}catch(t){console.error("Error dropping tables:",t),process.exit(1)}}var g=new He;g.name("mizzle").description("Mizzle Migration CLI").version("0.0.1");g.command("init").description("Initialize Mizzle configuration").action(async()=>{try{await G()}catch(e){let n=e instanceof Error?e.message:String(e);b.log.error(n),process.exit(1)}});g.command("generate").description("Generate a new migration snapshot and script").option("-n, --name <name>","Migration name").action(async e=>{try{let n=await N();await F({config:n,name:e.name})}catch(n){let t=n instanceof Error?n.message:String(n);b.log.error(t),process.exit(1)}});g.command("push").description("Directly apply schema changes to the target DynamoDB environment").option("-y, --yes","Skip confirmation").action(async e=>{try{let n=await N();await Z({config:n,force:e.yes})}catch(n){let t=n instanceof Error?n.message:String(n);b.log.error(t),process.exit(1)}});g.command("list").description("List all existing DynamoDB tables in the environment").action(async()=>{try{let e=await N();await W({config:e})}catch(e){let n=e instanceof Error?e.message:String(e);b.log.error(n),process.exit(1)}});g.command("drop").description("Interactive command to select and delete DynamoDB tables").action(async()=>{try{let e=await N();await J({config:e})}catch(e){let n=e instanceof Error?e.message:String(e);b.log.error(n),process.exit(1)}});g.parse();

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@aurios/mizzling",
+  "version": "1.0.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "mizzling": "./dist/index.js"
+  },
+  "author": {
+    "name": "Lucas",
+    "url": "https://github.com/realfakenerd"
+  },
+  "repository": {
+    "url": "https://github.com/realfakenerd/mizzle"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "tsup",
+    "lint": "eslint \"src/**/*.ts\""
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "3.962.0",
+    "@aws-sdk/credential-provider-ini": "3.962.0",
+    "@aws-sdk/lib-dynamodb": "3.962.0",
+    "@clack/prompts": "^0.11.0",
+    "@mizzle/shared": "workspace:*",
+    "@smithy/node-http-handler": "^4.4.7",
+    "commander": "^14.0.2",
+    "fast-glob": "^3.3.3"
+  },
+  "devDependencies": {
+    "@mizzle/eslint-config": "workspace:*",
+    "@mizzle/tsconfig": "workspace:*",
+    "@aurios/mizzle": "workspace:*",
+    "tsup": "^8.5.1"
+  }
+}

package/src/commands/drop.ts

@@ -0,0 +1,71 @@
+import { type MizzleConfig, getClient } from "../config";
+import { DynamoDBClient, ListTablesCommand, DeleteTableCommand } from "@aws-sdk/client-dynamodb";
+import { intro, outro, multiselect, confirm, isCancel, cancel, spinner } from "@clack/prompts";
+
+interface DropOptions {
+    config: MizzleConfig;
+    client?: DynamoDBClient;
+}
+
+export async function dropCommand(options: DropOptions) {
+    intro("Mizzle Drop Tables");
+
+    const client = options.client || getClient(options.config);
+    
+    try {
+        // 1. Fetch tables
+        const listCmd = new ListTablesCommand({});
+        const listRes = await client.send(listCmd);
+        const tableNames = listRes.TableNames || [];
+
+        if (tableNames.length === 0) {
+            console.log("No tables found in the remote environment.");
+            outro("Done");
+            return;
+        }
+
+        // 2. Select tables
+        const selectedTables = await multiselect({
+            message: "Select tables to DELETE (This action is irreversible!)",
+            options: tableNames.map(name => ({ value: name, label: name }))
+        });
+
+        if (isCancel(selectedTables)) {
+            cancel("Operation cancelled.");
+            return;
+        }
+
+        const tablesToDelete = selectedTables as string[];
+        if (tablesToDelete.length === 0) {
+            console.log("No tables selected.");
+            outro("Done");
+            return;
+        }
+
+        // 3. Confirm
+        const confirmed = await confirm({
+            message: `Are you SURE you want to delete ${tablesToDelete.length} table(s)?`
+        });
+
+        if (isCancel(confirmed) || !confirmed) {
+            console.log("Operation cancelled.");
+            outro("Done");
+            return;
+        }
+
+        // 4. Delete
+        const s = spinner();
+        s.start("Deleting tables...");
+
+        for (const tableName of tablesToDelete) {
+            s.message(`Deleting ${tableName}...`);
+            await client.send(new DeleteTableCommand({ TableName: tableName }));
+        }
+
+        s.stop("All selected tables deleted.");
+        outro("Done");
+    } catch (error) {
+        console.error("Error dropping tables:", error);
+        process.exit(1);
+    }
+}

package/src/commands/generate.ts

@@ -0,0 +1,116 @@
+import { type MizzleConfig } from "../config";
+import { discoverSchema } from "../discovery";
+import { loadSnapshot, saveSnapshot, generateSnapshot, getNextMigrationVersion } from "@aurios/mizzle/snapshot";
+import { compareSchema, type SchemaChange } from "@aurios/mizzle/diff";
+import { join } from "path";
+import { writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { text, isCancel, cancel, intro, outro } from "@clack/prompts";
+
+interface GenerateOptions {
+    config: MizzleConfig;
+    name?: string;
+    discoverSchema?: typeof discoverSchema;
+}
+
+export async function generateCommand(options: GenerateOptions) {
+    intro("Mizzle Generate");
+    const { config } = options;
+    const discover = options.discoverSchema || discoverSchema;
+
+    try {
+        // 1. Discover Schema
+        const schema = await discover(config); // Returns { tables, entities }
+        
+        // 2. Load Snapshot
+        const migrationsDir = config.out;
+        const existingSnapshot = await loadSnapshot(migrationsDir) || { version: "0", tables: {} };
+
+        // 3. Compare
+        const currentSnapshot = generateSnapshot(schema);
+        const changes = compareSchema(schema, existingSnapshot);
+
+        if (changes.length === 0) {
+            outro("No changes detected.");
+            return;
+        }
+
+        console.log(`Detected ${changes.length} changes.`);
+
+        // 4. Generate Migration Script
+        const version = await getNextMigrationVersion(migrationsDir);
+        
+        let name = options.name;
+        if (!name) {
+            name = await text({
+                message: "Enter migration name",
+                placeholder: "init",
+                initialValue: "migration",
+                validate(value) {
+                    if (value.length === 0) return "Name is required";
+                }
+            }) as string;
+        }
+
+        if (isCancel(name)) {
+            cancel("Operation cancelled.");
+            return;
+        }
+
+        const filename = `${version}_${name}.ts`;
+        if (!existsSync(migrationsDir)) {
+            await mkdir(migrationsDir, { recursive: true });
+        }
+        const filePath = join(migrationsDir, filename);
+
+        const scriptContent = generateMigrationScript(changes);
+        await writeFile(filePath, scriptContent);
+        console.log(`Created migration: ${filename}`);
+
+        // 5. Save new Snapshot
+        await saveSnapshot(migrationsDir, currentSnapshot);
+        outro("Updated snapshot.json");
+    } catch (error) {
+        console.error("Error generating migration:", error);
+        process.exit(1);
+    }
+}
+
+function generateMigrationScript(changes: SchemaChange[]): string {
+    const upSteps: string[] = [];
+    const downSteps: string[] = [];
+
+    for (const change of changes) {
+        if (change.type === "create") {
+            upSteps.push(`// Create Table: ${change.table.TableName}`);
+            upSteps.push(`await db.createTable("${change.table.TableName}", ${JSON.stringify(change.table, null, 2)});
+`);
+            
+            downSteps.unshift(`// Drop Table: ${change.table.TableName}`);
+            downSteps.unshift(`await db.deleteTable("${change.table.TableName}");
+`);
+        } else if (change.type === "delete") {
+            upSteps.push(`// Drop Table: ${change.tableName}`);
+            upSteps.push(`await db.deleteTable("${change.tableName}");
+`);
+            
+            downSteps.unshift(`// Create Table: ${change.tableName}`);
+            downSteps.unshift(`// TODO: Restore table definition for rollback
+`);
+        } else if (change.type === "update") {
+            upSteps.push(`// Update Table: ${change.tableName}`);
+            downSteps.unshift(`// Revert Update Table: ${change.tableName}`);
+        }
+    }
+
+    return `import { Mizzle } from "@aurios/mizzle";
+
+export async function up(db: Mizzle) {
+    ${upSteps.join("    ")}
+}
+
+export async function down(db: Mizzle) {
+    ${downSteps.join("    ")}
+}
+`;
+}

package/src/commands/init.ts

@@ -0,0 +1,77 @@
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+import { intro, outro, text, isCancel, cancel } from "@clack/prompts";
+
+export async function initCommand() {
+  const configPath = join(process.cwd(), "mizzle.config.ts");
+
+  if (existsSync(configPath)) {
+    console.log("mizzle.config.ts already exists in the current directory. Aborting.");
+    return;
+  }
+
+  intro("Mizzle Initialization");
+
+  const schema = await text({
+    message: "Where is your schema file or directory located?",
+    placeholder: "./src/schema.ts",
+    initialValue: "./src/schema.ts",
+    validate: (value) => {
+      if (!value) return "Schema path is required";
+    },
+  });
+
+  if (isCancel(schema)) {
+    cancel("Operation cancelled.");
+    return;
+  }
+
+  const out = await text({
+    message: "Where should Mizzle store migrations and snapshots?",
+    placeholder: "./migrations",
+    initialValue: "./migrations",
+    validate: (value) => {
+      if (!value) return "Output directory is required";
+    },
+  });
+
+  if (isCancel(out)) {
+    cancel("Operation cancelled.");
+    return;
+  }
+
+  const region = await text({
+    message: "Which AWS region do you want to use?",
+    placeholder: "us-east-1",
+    initialValue: "us-east-1",
+  });
+
+  if (isCancel(region)) {
+    cancel("Operation cancelled.");
+    return;
+  }
+
+  const endpoint = await text({
+    message: "Do you want to use a custom endpoint (e.g., for local development)?",
+    placeholder: "http://localhost:8000 (optional)",
+  });
+
+  if (isCancel(endpoint)) {
+    cancel("Operation cancelled.");
+    return;
+  }
+
+  const configContent = `import { defineConfig } from "@aurios/mizzle";
+
+export default defineConfig({
+  schema: "${schema}",
+  out: "${out}",
+  region: "${region}",
+  ${endpoint ? `endpoint: "${endpoint}",` : "// endpoint: \"http://localhost:8000\","}
+});
+`;
+
+  writeFileSync(configPath, configContent);
+
+  outro(`mizzle.config.ts created successfully!`);
+}

package/src/commands/list.ts

@@ -0,0 +1,48 @@
+import { type MizzleConfig, getClient } from "../config";
+import { getRemoteSnapshot } from "@aurios/mizzle/introspection";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { intro, outro, spinner } from "@clack/prompts";
+
+interface ListOptions {
+    config: MizzleConfig;
+    client?: DynamoDBClient;
+}
+
+export async function listCommand(options: ListOptions) {
+    intro("Mizzle List Tables");
+    
+    const client = options.client || getClient(options.config);
+    const s = spinner();
+    s.start("Fetching remote tables...");
+
+    try {
+        const snapshot = await getRemoteSnapshot(client);
+        s.stop("Fetched remote tables.");
+        
+        const tables = Object.values(snapshot.tables);
+
+        if (tables.length === 0) {
+            console.log("No tables found in the remote environment.");
+            outro("Done");
+            return;
+        }
+
+        console.log(`Found ${tables.length} tables:`);
+        for (const table of tables) {
+            console.log(`- ${table.TableName}`);
+            const pk = table.KeySchema.find(k => k.KeyType === "HASH")?.AttributeName;
+            const sk = table.KeySchema.find(k => k.KeyType === "RANGE")?.AttributeName;
+            console.log(`  PK: ${pk}, SK: ${sk || "(none)"}`);
+            
+            if (table.GlobalSecondaryIndexes && table.GlobalSecondaryIndexes.length > 0) {
+                 console.log(`  GSIs: ${table.GlobalSecondaryIndexes.map(g => g.IndexName).join(", ")}`);
+            }
+        }
+
+        outro("Done");
+    } catch (error) {
+        s.stop("Failed to fetch tables.");
+        console.error("Error listing tables:", error);
+        process.exit(1);
+    }
+}

package/src/commands/push.ts

@@ -0,0 +1,75 @@
+import { type MizzleConfig, getClient } from "../config";
+import { discoverSchema } from "../discovery";
+import { compareSchema } from "@aurios/mizzle/diff";
+import { getRemoteSnapshot } from "@aurios/mizzle/introspection";
+import { DynamoDBClient, CreateTableCommand, DeleteTableCommand } from "@aws-sdk/client-dynamodb";
+import { confirm, isCancel, cancel, intro, outro, spinner } from "@clack/prompts";
+
+interface PushOptions {
+    config: MizzleConfig;
+    force?: boolean;
+    discoverSchema?: typeof discoverSchema;
+    client?: DynamoDBClient;
+}
+
+export async function pushCommand(options: PushOptions) {
+    intro("Mizzle Push");
+    const { config, force } = options;
+    const discover = options.discoverSchema || discoverSchema;
+    
+    const client = options.client || getClient(config); 
+
+    try {
+        const schema = await discover(config);
+        const remoteSnapshot = await getRemoteSnapshot(client);
+
+        const changes = compareSchema(schema, remoteSnapshot);
+
+        if (changes.length === 0) {
+            outro("Remote is up to date.");
+            return;
+        }
+
+        console.log(`Pushing ${changes.length} changes to remote...`);
+
+        let shouldContinue = force;
+        if (!shouldContinue) {
+            shouldContinue = await confirm({
+                message: "Do you want to apply these changes?"
+            }) as boolean;
+        }
+
+        if (isCancel(shouldContinue) || !shouldContinue) {
+            cancel("Operation cancelled.");
+            return;
+        }
+
+        const s = spinner();
+        s.start("Pushing changes...");
+
+        for (const change of changes) {
+            if (change.type === "create") {
+                s.message(`Creating table: ${change.table.TableName}`);
+                await client.send(
+                    new CreateTableCommand({
+                        TableName: change.table.TableName,
+                        AttributeDefinitions: change.table.AttributeDefinitions,
+                        KeySchema: change.table.KeySchema,
+                        GlobalSecondaryIndexes: change.table.GlobalSecondaryIndexes,
+                        LocalSecondaryIndexes: change.table.LocalSecondaryIndexes,
+                        BillingMode: "PAY_PER_REQUEST",
+                    }),
+                );
+            } else if (change.type === "delete") {
+                console.log(`Untracked table found: ${change.tableName} (Skipping deletion)`);
+            } else if (change.type === "update") {
+                s.message(`Updating table: ${change.tableName} (Not fully implemented)`);
+            }
+        }
+        s.stop("Push complete.");
+        outro("Done");
+    } catch (error) {
+        console.error("Error pushing changes:", error);
+        process.exit(1);
+    }
+}

package/src/config.ts

@@ -0,0 +1,163 @@
+import { join } from "path";
+import { existsSync } from "fs";
+import { DynamoDBClient, type DynamoDBClientConfig } from "@aws-sdk/client-dynamodb";
+import { fromIni } from "@aws-sdk/credential-provider-ini";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
+import http from "http";
+import https from "https";
+
+/**
+ * Configuration for Mizzle ORM.
+ */
+export interface MizzleConfig {
+  /**
+   * Path or glob pattern(s) to the schema files.
+   */
+  schema: string | string[];
+  /**
+   * Directory where generated migrations and snapshots will be stored.
+   */
+  out: string;
+  /**
+   * AWS Region to connect to. Defaults to "us-east-1" if not specified.
+   * Can be overridden by MIZZLE_REGION environment variable.
+   */
+  region?: string;
+  /**
+   * Optional custom endpoint for DynamoDB (e.g., for local development).
+   * Can be overridden by MIZZLE_ENDPOINT environment variable.
+   */
+  endpoint?: string;
+  /**
+   * Explicit AWS credentials. If provided, these will be used instead of the
+   * default credential provider chain or profile.
+   */
+  credentials?: {
+    /**
+     * AWS Access Key ID.
+     */
+    accessKeyId: string;
+    /**
+     * AWS Secret Access Key.
+     */
+    secretAccessKey: string;
+    /**
+     * Optional AWS Session Token.
+     */
+    sessionToken?: string;
+  };
+  /**
+   * AWS Profile name to use for credentials.
+   */
+  profile?: string;
+  /**
+   * Maximum number of retry attempts for DynamoDB requests.
+   */
+  maxAttempts?: number;
+}
+
+/**
+ * Helper function to define the configuration with type safety.
+ * 
+ * @param config The Mizzle configuration object.
+ * @returns The same configuration object, validated by TypeScript.
+ */
+export function defineConfig(config: MizzleConfig): MizzleConfig {
+  return config;
+}
+
+/**
+ * Creates a configured DynamoDBClient instance based on the provided configuration.
+ * 
+ * It prioritizes credentials in the following order:
+ * 1. Explicitly provided `credentials` object.
+ * 2. Explicitly provided AWS `profile`.
+ * 3. Default "local" credentials if the endpoint is localhost/127.0.0.1.
+ * 4. Default AWS SDK credential provider chain (environment variables, IAM roles, etc.).
+ * 
+ * @param config The Mizzle configuration.
+ * @returns A configured DynamoDBClient instance.
+ */
+export function getClient(config: MizzleConfig): DynamoDBClient {
+  const agentOptions = {
+      keepAlive: true,
+      maxSockets: Infinity,
+  };
+
+  const clientConfig: DynamoDBClientConfig = {
+    region: config.region || "us-east-1",
+    endpoint: config.endpoint,
+    maxAttempts: config.maxAttempts,
+    requestHandler: new NodeHttpHandler({
+        httpAgent: new http.Agent(agentOptions),
+        httpsAgent: new https.Agent(agentOptions),
+    }),
+  };
+
+  if (config.credentials) {
+    clientConfig.credentials = config.credentials;
+  } else if (config.profile) {
+    clientConfig.credentials = fromIni({ profile: config.profile });
+  } else if (
+    config.endpoint &&
+    (config.endpoint.includes("localhost") || config.endpoint.includes("127.0.0.1"))
+  ) {
+    clientConfig.credentials = {
+      accessKeyId: "local",
+      secretAccessKey: "local",
+    };
+  }
+
+  return new DynamoDBClient(clientConfig);
+}
+
+/**
+ * Loads the Mizzle configuration from a file (defaulting to mizzle.config.ts).
+ * 
+ * Environment variables (MIZZLE_REGION, MIZZLE_ENDPOINT, MIZZLE_SCHEMA, MIZZLE_OUT)
+ * will override values provided in the configuration file.
+ * 
+ * @param configName The name of the config file to load.
+ * @returns A promise that resolves to the loaded and overridden configuration.
+ * @throws Error if the configuration file is missing or invalid.
+ */
+export async function loadConfig(configName = "mizzle.config.ts"): Promise<MizzleConfig> {
+  const envConfig = process.env.MIZZLE_CONFIG;
+  const configPath = envConfig || join(process.cwd(), configName);
+
+  if (!existsSync(configPath)) {
+    throw new Error(`Could not find ${configName} in current directory.`);
+  }
+
+  try {
+    const imported = await import(configPath);
+    const config = imported.default || imported;
+
+    if (!config || typeof config !== "object") {
+       throw new Error("Invalid config: default export must be an object");
+    }
+
+    if (!config.schema) {
+      throw new Error("Invalid config: missing 'schema' path");
+    }
+
+    if (!config.out) {
+      throw new Error("Invalid config: missing 'out' directory");
+    }
+
+    const finalConfig = { ...config } as MizzleConfig;
+
+    if (process.env.MIZZLE_REGION) finalConfig.region = process.env.MIZZLE_REGION;
+    if (process.env.MIZZLE_ENDPOINT) finalConfig.endpoint = process.env.MIZZLE_ENDPOINT;
+    if (process.env.MIZZLE_SCHEMA) finalConfig.schema = process.env.MIZZLE_SCHEMA;
+    if (process.env.MIZZLE_OUT) finalConfig.out = process.env.MIZZLE_OUT;
+
+    return finalConfig;
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Invalid config")) {
+        throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load config: ${message}`);
+  }
+}

package/src/discovery.ts

@@ -0,0 +1,63 @@
+import { type MizzleConfig } from "./config";
+import { PhysicalTable, Entity } from "@aurios/mizzle/table";
+import { TABLE_SYMBOLS, ENTITY_SYMBOLS } from "@mizzle/shared";
+import fg from "fast-glob";
+import { stat } from "fs/promises";
+import { resolve } from "path";
+
+export async function discoverSchema(config: MizzleConfig): Promise<{ tables: PhysicalTable[], entities: Entity[] }> {
+  const schemaPatterns = Array.isArray(config.schema) ? config.schema : [config.schema];
+  const tables: PhysicalTable[] = [];
+  const entities: Entity[] = [];
+  const scannedFiles = new Set<string>();
+
+  const processFile = async (file: string) => {
+    const absolutePath = resolve(process.cwd(), file);
+    if (scannedFiles.has(absolutePath)) return;
+    scannedFiles.add(absolutePath);
+    
+    try {
+        const imported = await import(absolutePath);
+        for (const key in imported) {
+            const exportVal = imported[key];
+            if (!exportVal || typeof exportVal !== "object") continue;
+
+            if (exportVal instanceof PhysicalTable || exportVal[TABLE_SYMBOLS.TABLE_NAME] !== undefined) {
+                tables.push(exportVal as PhysicalTable);
+            } else if (exportVal instanceof Entity || exportVal[ENTITY_SYMBOLS.ENTITY_NAME] !== undefined) {
+                entities.push(exportVal as Entity);
+            }
+        }
+    } catch (e) {
+        console.warn(`Failed to import schema file: ${absolutePath}`, e);
+    }
+  };
+
+  for (const pattern of schemaPatterns) {
+    let searchPattern = pattern;
+    let isDirectFile = false;
+    
+    try {
+        const stats = await stat(pattern);
+        if (stats.isDirectory()) {
+            searchPattern = `${pattern}/**/*.{ts,js,tsx,jsx}`;
+        } else if (stats.isFile()) {
+            isDirectFile = true;
+        }
+    } catch {
+        // Not a file/dir, assume it's a glob pattern
+    }
+
+    if (isDirectFile) {
+        await processFile(pattern);
+        continue;
+    }
+
+    const files = await fg(searchPattern, { absolute: true });
+    for (const file of files) {
+        await processFile(file);
+    }
+  }
+
+  return { tables, entities };
+}

package/src/index.ts

@@ -0,0 +1,88 @@
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { loadConfig } from "./config";
+import { generateCommand } from "./commands/generate";
+import { initCommand } from "./commands/init";
+import { pushCommand } from "./commands/push";
+import { listCommand } from "./commands/list";
+import { dropCommand } from "./commands/drop";
+
+const program = new Command();
+
+program
+  .name("mizzle")
+  .description("Mizzle Migration CLI")
+  .version("0.0.1");
+
+program
+  .command("init")
+  .description("Initialize Mizzle configuration")
+  .action(async () => {
+    try {
+        await initCommand();
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        p.log.error(message);
+        process.exit(1);
+    }
+  });
+
+program
+  .command("generate")
+  .description("Generate a new migration snapshot and script")
+  .option("-n, --name <name>", "Migration name")
+  .action(async (options) => {
+    try {
+        const config = await loadConfig();
+        await generateCommand({ config, name: options.name });
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        p.log.error(message);
+        process.exit(1);
+    }
+  });
+
+program
+  .command("push")
+  .description("Directly apply schema changes to the target DynamoDB environment")
+  .option("-y, --yes", "Skip confirmation")
+  .action(async (options) => {
+    try {
+        const config = await loadConfig();
+        await pushCommand({ config, force: options.yes });
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        p.log.error(message);
+        process.exit(1);
+    }
+  });
+
+program
+  .command("list")
+  .description("List all existing DynamoDB tables in the environment")
+  .action(async () => {
+    try {
+        const config = await loadConfig();
+        await listCommand({ config });
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        p.log.error(message);
+        process.exit(1);
+    }
+  });
+
+program
+  .command("drop")
+  .description("Interactive command to select and delete DynamoDB tables")
+  .action(async () => {
+    try {
+        const config = await loadConfig();
+        await dropCommand({ config });
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        p.log.error(message);
+        process.exit(1);
+    }
+  });
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@mizzle/tsconfig/base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@mizzle/shared": ["../shared/src/index.ts"],
+      "mizzle": ["../mizzle/src/index.ts"],
+      "mizzle/*": ["../mizzle/src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  clean: true,
+  noExternal: ['@mizzle/shared', 'mizzle'],
+  minify: true,
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+});