@livestore/cli 0.4.0 → 0.5.0-dev.0

package/src/mcp-content/schemas/ecommerce.ts

@@ -22,7 +22,7 @@ export const tables = {
       deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   categories: State.SQLite.table({
     name: 'categories',
     columns: {
@@ -37,7 +37,7 @@ export const tables = {
       createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   productCategories: State.SQLite.table({
     name: 'product_categories',
     columns: {
@@ -46,7 +46,7 @@ export const tables = {
       createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   customers: State.SQLite.table({
     name: 'customers',
     columns: {
@@ -59,7 +59,7 @@ export const tables = {
       lastOrderAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   addresses: State.SQLite.table({
     name: 'addresses',
     columns: {
@@ -78,7 +78,7 @@ export const tables = {
       isDefault: State.SQLite.boolean({ default: false }),
     },
   }),
-  
+
   orders: State.SQLite.table({
     name: 'orders',
     columns: {
@@ -88,19 +88,19 @@ export const tables = {
       status: State.SQLite.text({ default: 'draft' }), // draft, pending, paid, processing, shipped, delivered, cancelled
       paymentStatus: State.SQLite.text({ default: 'pending' }), // pending, paid, failed, refunded
       fulfillmentStatus: State.SQLite.text({ default: 'unfulfilled' }), // unfulfilled, partial, fulfilled
-      
+
       subtotal: State.SQLite.integer(), // In cents
       taxAmount: State.SQLite.integer({ default: 0 }),
       shippingAmount: State.SQLite.integer({ default: 0 }),
       discountAmount: State.SQLite.integer({ default: 0 }),
       total: State.SQLite.integer(),
       currency: State.SQLite.text({ default: 'USD' }),
-      
+
       shippingAddress: State.SQLite.text(), // JSON
       billingAddress: State.SQLite.text(), // JSON
-      
+
       notes: State.SQLite.text({ nullable: true }),
-      
+
       createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
       updatedAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
       cancelledAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
@@ -108,7 +108,7 @@ export const tables = {
       deliveredAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   orderItems: State.SQLite.table({
     name: 'order_items',
     columns: {
@@ -124,7 +124,7 @@ export const tables = {
       fulfillmentStatus: State.SQLite.text({ default: 'unfulfilled' }),
     },
   }),
-  
+
   // Inventory tracking with event sourcing
   inventoryEvents: State.SQLite.table({
     name: 'inventory_events',
@@ -138,7 +138,7 @@ export const tables = {
       createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   // Shopping cart (client-side state)
   cart: State.SQLite.clientDocument({
     name: 'cart',
@@ -151,8 +151,8 @@ export const tables = {
       discountCode: Schema.NullOr(Schema.String),
       notes: Schema.String,
     }),
-    default: { 
-      id: SessionIdSymbol, 
+    default: {
+      id: SessionIdSymbol,
       value: { items: [], discountCode: null, notes: '' }
     },
   }),
@@ -172,7 +172,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   productUpdated: Events.synced({
     name: 'v1.ProductUpdated',
     schema: Schema.Struct({
@@ -183,7 +183,7 @@ export const events = {
       updatedAt: Schema.Date,
     }),
   }),
-  
+
   productStockAdjusted: Events.synced({
     name: 'v1.ProductStockAdjusted',
     schema: Schema.Struct({
@@ -194,12 +194,12 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   productDeactivated: Events.synced({
     name: 'v1.ProductDeactivated',
     schema: Schema.Struct({ id: Schema.String }),
   }),
-  
+
   // Customer management
   customerCreated: Events.synced({
     name: 'v1.CustomerCreated',
@@ -211,7 +211,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   // Order lifecycle with state machine
   orderCreated: Events.synced({
     name: 'v1.OrderCreated',
@@ -233,7 +233,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   orderPaymentReceived: Events.synced({
     name: 'v1.OrderPaymentReceived',
     schema: Schema.Struct({
@@ -244,7 +244,7 @@ export const events = {
       paidAt: Schema.Date,
     }),
   }),
-  
+
   orderShipped: Events.synced({
     name: 'v1.OrderShipped',
     schema: Schema.Struct({
@@ -254,7 +254,7 @@ export const events = {
       shippedAt: Schema.Date,
     }),
   }),
-  
+
   orderDelivered: Events.synced({
     name: 'v1.OrderDelivered',
     schema: Schema.Struct({
@@ -262,7 +262,7 @@ export const events = {
       deliveredAt: Schema.Date,
     }),
   }),
-  
+
   orderCancelled: Events.synced({
     name: 'v1.OrderCancelled',
     schema: Schema.Struct({
@@ -271,7 +271,7 @@ export const events = {
       cancelledAt: Schema.Date,
     }),
   }),
-  
+
   // Cart management (local)
   cartUpdated: tables.cart.set,
 }
@@ -281,58 +281,58 @@ const materializers = State.SQLite.materializers(events, {
   // Product materializers
   'v1.ProductCreated': ({ id, sku, name, description, price, currency, createdAt }) =>
     tables.products.insert({ id, sku, name, description, price, currency, createdAt, updatedAt: createdAt }),
-    
+
   'v1.ProductUpdated': ({ id, name, description, price, updatedAt }) =>
-    tables.products.update({ 
+    tables.products.update({
       name: name ?? undefined,
-      description: description ?? undefined, 
+      description: description ?? undefined,
       price: price ?? undefined,
-      updatedAt 
+      updatedAt
     }).where({ id }),
-    
+
   'v1.ProductStockAdjusted': ({ productId, adjustment, reason, referenceId, createdAt }) => [
     // Record the inventory event
-    tables.inventoryEvents.insert({ 
+    tables.inventoryEvents.insert({
       id: crypto.randomUUID(),
-      productId, 
+      productId,
       type: 'adjustment',
-      quantity: adjustment, 
-      reason, 
-      referenceId, 
-      createdAt 
+      quantity: adjustment,
+      reason,
+      referenceId,
+      createdAt
     }),
     // Update product stock (eventually consistent)
-    tables.products.update({ 
+    tables.products.update({
       stock: Math.max(0, tables.products.select('stock').where({ id: productId }).scalar() + adjustment),
       updatedAt: createdAt
     }).where({ id: productId }),
   ],
-    
+
   'v1.ProductDeactivated': ({ id }) =>
     tables.products.update({ isActive: false }).where({ id }),
-    
+
   // Customer materializers
   'v1.CustomerCreated': ({ id, email, firstName, lastName, createdAt }) =>
     tables.customers.insert({ id, email, firstName, lastName, createdAt }),
-    
+
   // Order materializers with inventory reservation
   'v1.OrderCreated': ({ id, orderNumber, customerId, items, subtotal, total, shippingAddress, billingAddress, createdAt }) => [
     // Create the order
-    tables.orders.insert({ 
-      id, 
-      orderNumber, 
-      customerId, 
+    tables.orders.insert({
+      id,
+      orderNumber,
+      customerId,
       status: 'pending',
-      subtotal, 
-      total, 
+      subtotal,
+      total,
       shippingAddress: JSON.stringify(shippingAddress),
       billingAddress: JSON.stringify(billingAddress),
-      createdAt, 
-      updatedAt: createdAt 
+      createdAt,
+      updatedAt: createdAt
     }),
     // Create order items and reserve inventory
     ...items.flatMap(item => [
-      tables.orderItems.insert({ 
+      tables.orderItems.insert({
         id: crypto.randomUUID(),
         orderId: id,
         productId: item.productId,
@@ -343,52 +343,52 @@ const materializers = State.SQLite.materializers(events, {
         totalPrice: item.quantity * item.unitPrice,
       }),
       // Reserve stock
-      tables.products.update({ 
+      tables.products.update({
         reservedStock: tables.products.select('reservedStock').where({ id: item.productId }).scalar() + item.quantity
       }).where({ id: item.productId }),
     ]),
   ],
-    
+
   'v1.OrderPaymentReceived': ({ orderId, amount, paymentMethod, transactionId, paidAt }) =>
-    tables.orders.update({ 
-      status: 'paid', 
+    tables.orders.update({
+      status: 'paid',
       paymentStatus: 'paid',
-      updatedAt: paidAt 
+      updatedAt: paidAt
     }).where({ id: orderId }),
-    
+
   'v1.OrderShipped': ({ orderId, trackingNumber, carrier, shippedAt }) => [
-    tables.orders.update({ 
+    tables.orders.update({
       status: 'shipped',
       fulfillmentStatus: 'fulfilled',
       shippedAt,
-      updatedAt: shippedAt 
+      updatedAt: shippedAt
     }).where({ id: orderId }),
     // Convert reserved stock to actual stock reduction
-    ...tables.orderItems.select().where({ orderId }).map(item => 
-      tables.products.update({ 
+    ...tables.orderItems.select().where({ orderId }).map(item =>
+      tables.products.update({
         stock: tables.products.select('stock').where({ id: item.productId }).scalar() - item.quantity,
         reservedStock: tables.products.select('reservedStock').where({ id: item.productId }).scalar() - item.quantity
       }).where({ id: item.productId })
     ),
   ],
-    
+
   'v1.OrderDelivered': ({ orderId, deliveredAt }) =>
-    tables.orders.update({ 
+    tables.orders.update({
       status: 'delivered',
       deliveredAt,
-      updatedAt: deliveredAt 
+      updatedAt: deliveredAt
     }).where({ id: orderId }),
-    
+
   'v1.OrderCancelled': ({ orderId, reason, cancelledAt }) => [
-    tables.orders.update({ 
+    tables.orders.update({
       status: 'cancelled',
       cancelledAt,
       notes: reason,
-      updatedAt: cancelledAt 
+      updatedAt: cancelledAt
     }).where({ id: orderId }),
     // Release reserved inventory
-    ...tables.orderItems.select().where({ orderId }).map(item => 
-      tables.products.update({ 
+    ...tables.orderItems.select().where({ orderId }).map(item =>
+      tables.products.update({
         reservedStock: Math.max(0, tables.products.select('reservedStock').where({ id: item.productId }).scalar() - item.quantity)
       }).where({ id: item.productId })
     ),
@@ -416,7 +416,7 @@ export const schema = makeSchema({ events, state })
 //   tables.orders
 //     .select()
 //     .join(tables.customers, 'customerId', 'id')
-//     .where({ 
+//     .where({
 //       'orders.status': 'paid',
 //       'orders.fulfillmentStatus': 'unfulfilled'
 //     })

package/src/mcp-content/schemas/social.ts

@@ -19,7 +19,7 @@ export const tables = {
       allowsFollowers: State.SQLite.boolean({ default: true }),
     },
   }),
-  
+
   posts: State.SQLite.table({
     name: 'posts',
     columns: {
@@ -34,7 +34,7 @@ export const tables = {
       deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   follows: State.SQLite.table({
     name: 'follows',
     columns: {
@@ -45,7 +45,7 @@ export const tables = {
       approvedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   likes: State.SQLite.table({
     name: 'likes',
     columns: {
@@ -54,7 +54,7 @@ export const tables = {
       createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   // Aggregate tables for performance (eventually consistent)
   postStats: State.SQLite.table({
     name: 'post_stats',
@@ -66,9 +66,9 @@ export const tables = {
       lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   userStats: State.SQLite.table({
-    name: 'user_stats', 
+    name: 'user_stats',
     columns: {
       userId: State.SQLite.text({ primaryKey: true }),
       followerCount: State.SQLite.integer({ default: 0 }),
@@ -77,7 +77,7 @@ export const tables = {
       lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
     },
   }),
-  
+
   // Client-side state for UI
   feedState: State.SQLite.clientDocument({
     name: 'feedState',
@@ -86,8 +86,8 @@ export const tables = {
       lastRefresh: Schema.Date,
       scrollPosition: Schema.Number,
     }),
-    default: { 
-      id: SessionIdSymbol, 
+    default: {
+      id: SessionIdSymbol,
       value: { currentFeed: 'home', lastRefresh: new Date(), scrollPosition: 0 }
     },
   }),
@@ -105,7 +105,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   userProfileUpdated: Events.synced({
     name: 'v1.UserProfileUpdated',
     schema: Schema.Struct({
@@ -115,7 +115,7 @@ export const events = {
       avatarUrl: Schema.NullOr(Schema.String),
     }),
   }),
-  
+
   userPrivacySettingsChanged: Events.synced({
     name: 'v1.UserPrivacySettingsChanged',
     schema: Schema.Struct({
@@ -124,7 +124,7 @@ export const events = {
       allowsFollowers: Schema.Boolean,
     }),
   }),
-  
+
   userLastActiveUpdated: Events.synced({
     name: 'v1.UserLastActiveUpdated',
     schema: Schema.Struct({
@@ -132,7 +132,7 @@ export const events = {
       lastActiveAt: Schema.Date,
     }),
   }),
-  
+
   // Post events
   postCreated: Events.synced({
     name: 'v1.PostCreated',
@@ -146,7 +146,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   postEdited: Events.synced({
     name: 'v1.PostEdited',
     schema: Schema.Struct({
@@ -155,7 +155,7 @@ export const events = {
       editedAt: Schema.Date,
     }),
   }),
-  
+
   postDeleted: Events.synced({
     name: 'v1.PostDeleted',
     schema: Schema.Struct({
@@ -163,7 +163,7 @@ export const events = {
       deletedAt: Schema.Date,
     }),
   }),
-  
+
   // Social interaction events
   followRequested: Events.synced({
     name: 'v1.FollowRequested',
@@ -173,7 +173,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   followApproved: Events.synced({
     name: 'v1.FollowApproved',
     schema: Schema.Struct({
@@ -182,7 +182,7 @@ export const events = {
       approvedAt: Schema.Date,
     }),
   }),
-  
+
   unfollowed: Events.synced({
     name: 'v1.Unfollowed',
     schema: Schema.Struct({
@@ -190,7 +190,7 @@ export const events = {
       followingId: Schema.String,
     }),
   }),
-  
+
   postLiked: Events.synced({
     name: 'v1.PostLiked',
     schema: Schema.Struct({
@@ -199,7 +199,7 @@ export const events = {
       createdAt: Schema.Date,
     }),
   }),
-  
+
   postUnliked: Events.synced({
     name: 'v1.PostUnliked',
     schema: Schema.Struct({
@@ -207,7 +207,7 @@ export const events = {
       postId: Schema.String,
     }),
   }),
-  
+
   // Local UI state
   feedStateUpdated: tables.feedState.set,
 }
@@ -219,85 +219,85 @@ const materializers = State.SQLite.materializers(events, {
     tables.users.insert({ id, username, email, displayName, createdAt }),
     tables.userStats.insert({ userId: id, lastUpdated: createdAt }),
   ],
-  
+
   'v1.UserProfileUpdated': ({ id, displayName, bio, avatarUrl }) =>
     tables.users.update({ displayName, bio, avatarUrl }).where({ id }),
-    
+
   'v1.UserPrivacySettingsChanged': ({ id, isPrivate, allowsFollowers }) =>
     tables.users.update({ isPrivate, allowsFollowers }).where({ id }),
-    
+
   'v1.UserLastActiveUpdated': ({ id, lastActiveAt }) =>
     tables.users.update({ lastActiveAt }).where({ id }),
-    
+
   // Post materializers
   'v1.PostCreated': ({ id, authorId, content, mediaUrls, replyToId, visibility, createdAt }) => [
-    tables.posts.insert({ 
-      id, 
-      authorId, 
-      content, 
+    tables.posts.insert({
+      id,
+      authorId,
+      content,
       mediaUrls: mediaUrls ? JSON.stringify(mediaUrls) : null,
-      replyToId, 
-      visibility, 
-      createdAt 
+      replyToId,
+      visibility,
+      createdAt
     }),
     tables.postStats.insert({ postId: id, lastUpdated: createdAt }),
     // Update user post count
-    tables.userStats.update({ 
+    tables.userStats.update({
       postCount: tables.userStats.select('postCount').where({ userId: authorId }).scalar() + 1,
       lastUpdated: createdAt
     }).where({ userId: authorId }),
   ],
-  
+
   'v1.PostEdited': ({ id, content, editedAt }) =>
     tables.posts.update({ content, editedAt }).where({ id }),
-    
+
   'v1.PostDeleted': ({ id, deletedAt }) =>
     tables.posts.update({ deletedAt }).where({ id }),
-    
+
   // Follow materializers
   'v1.FollowRequested': ({ followerId, followingId, createdAt }) =>
     tables.follows.insert({ followerId, followingId, status: 'pending', createdAt }),
-    
+
   'v1.FollowApproved': ({ followerId, followingId, approvedAt }) => [
     tables.follows.update({ status: 'active', approvedAt }).where({ followerId, followingId }),
     // Update follower counts
-    tables.userStats.update({ 
+    tables.userStats.update({
       followerCount: tables.userStats.select('followerCount').where({ userId: followingId }).scalar() + 1,
       lastUpdated: approvedAt
     }).where({ userId: followingId }),
-    tables.userStats.update({ 
+    tables.userStats.update({
       followingCount: tables.userStats.select('followingCount').where({ userId: followerId }).scalar() + 1,
       lastUpdated: approvedAt
     }).where({ userId: followerId }),
   ],
-  
+
   'v1.Unfollowed': ({ followerId, followingId }) => [
     tables.follows.delete().where({ followerId, followingId }),
     // Update follower counts (eventual consistency)
-    tables.userStats.update({ 
+    tables.userStats.update({
       followerCount: Math.max(0, tables.userStats.select('followerCount').where({ userId: followingId }).scalar() - 1),
       lastUpdated: new Date()
     }).where({ userId: followingId }),
-    tables.userStats.update({ 
+    tables.userStats.update({
       followingCount: Math.max(0, tables.userStats.select('followingCount').where({ userId: followerId }).scalar() - 1),
       lastUpdated: new Date()
     }).where({ userId: followerId }),
   ],
-  
+
   // Like materializers (idempotent)
   'v1.PostLiked': ({ userId, postId, createdAt }) => [
     tables.likes.insert({ userId, postId, createdAt }),
     // Update like count
-    tables.postStats.update({ 
+    tables.postStats.update({
       likeCount: tables.postStats.select('likeCount').where({ postId }).scalar() + 1,
       lastUpdated: createdAt
     }).where({ postId }),
   ],
-  
+
   'v1.PostUnliked': ({ userId, postId }) => [
     tables.likes.delete().where({ userId, postId }),
     // Update like count
-    tables.postStats.update({ 
+    tables.postStats.update({
       likeCount: Math.max(0, tables.postStats.select('likeCount').where({ postId }).scalar() - 1),
       lastUpdated: new Date()
     }).where({ postId }),
@@ -317,8 +317,8 @@ export const schema = makeSchema({ events, state })
 //     .join(tables.follows, 'authorId', 'followingId')
 //     .join(tables.users, 'authorId', 'id')
 //     .leftJoin(tables.postStats, 'id', 'postId')
-//     .where({ 
-//       followerId: userId, 
+//     .where({
+//       followerId: userId,
 //       'follows.status': 'active',
 //       'posts.deletedAt': null,
 //       'posts.visibility': ['public', 'followers']