@livestore/cli 0.0.0-snapshot-2ac5fd340c97c9e07fe4c5dc6d31d5132aa6557c.0

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

@@ -0,0 +1,338 @@
+export const socialSchemaContent = `import { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'
+
+// Social network with activity feeds and real-time interactions
+export const tables = {
+  users: State.SQLite.table({
+    name: 'users',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      username: State.SQLite.text(),
+      email: State.SQLite.text(),
+      displayName: State.SQLite.text(),
+      bio: State.SQLite.text({ nullable: true }),
+      avatarUrl: State.SQLite.text({ nullable: true }),
+      isVerified: State.SQLite.boolean({ default: false }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      lastActiveAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      // Privacy settings
+      isPrivate: State.SQLite.boolean({ default: false }),
+      allowsFollowers: State.SQLite.boolean({ default: true }),
+    },
+  }),
+  
+  posts: State.SQLite.table({
+    name: 'posts',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      authorId: State.SQLite.text(),
+      content: State.SQLite.text(),
+      mediaUrls: State.SQLite.text({ nullable: true }), // JSON array of media URLs
+      replyToId: State.SQLite.text({ nullable: true }), // For threading
+      visibility: State.SQLite.text({ default: 'public' }), // public, followers, private
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      editedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  follows: State.SQLite.table({
+    name: 'follows',
+    columns: {
+      followerId: State.SQLite.text(),
+      followingId: State.SQLite.text(),
+      status: State.SQLite.text({ default: 'active' }), // active, pending, blocked
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      approvedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  likes: State.SQLite.table({
+    name: 'likes',
+    columns: {
+      userId: State.SQLite.text(),
+      postId: State.SQLite.text(),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  // Aggregate tables for performance (eventually consistent)
+  postStats: State.SQLite.table({
+    name: 'post_stats',
+    columns: {
+      postId: State.SQLite.text({ primaryKey: true }),
+      likeCount: State.SQLite.integer({ default: 0 }),
+      replyCount: State.SQLite.integer({ default: 0 }),
+      shareCount: State.SQLite.integer({ default: 0 }),
+      lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  userStats: State.SQLite.table({
+    name: 'user_stats', 
+    columns: {
+      userId: State.SQLite.text({ primaryKey: true }),
+      followerCount: State.SQLite.integer({ default: 0 }),
+      followingCount: State.SQLite.integer({ default: 0 }),
+      postCount: State.SQLite.integer({ default: 0 }),
+      lastUpdated: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  
+  // Client-side state for UI
+  feedState: State.SQLite.clientDocument({
+    name: 'feedState',
+    schema: Schema.Struct({
+      currentFeed: Schema.Literal('home', 'discover', 'following'),
+      lastRefresh: Schema.Date,
+      scrollPosition: Schema.Number,
+    }),
+    default: { 
+      id: SessionIdSymbol, 
+      value: { currentFeed: 'home', lastRefresh: new Date(), scrollPosition: 0 }
+    },
+  }),
+}
+
+export const events = {
+  // User events
+  userCreated: Events.synced({
+    name: 'v1.UserCreated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      username: Schema.String,
+      email: Schema.String,
+      displayName: Schema.String,
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  userProfileUpdated: Events.synced({
+    name: 'v1.UserProfileUpdated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      displayName: Schema.NullOr(Schema.String),
+      bio: Schema.NullOr(Schema.String),
+      avatarUrl: Schema.NullOr(Schema.String),
+    }),
+  }),
+  
+  userPrivacySettingsChanged: Events.synced({
+    name: 'v1.UserPrivacySettingsChanged',
+    schema: Schema.Struct({
+      id: Schema.String,
+      isPrivate: Schema.Boolean,
+      allowsFollowers: Schema.Boolean,
+    }),
+  }),
+  
+  userLastActiveUpdated: Events.synced({
+    name: 'v1.UserLastActiveUpdated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      lastActiveAt: Schema.Date,
+    }),
+  }),
+  
+  // Post events
+  postCreated: Events.synced({
+    name: 'v1.PostCreated',
+    schema: Schema.Struct({
+      id: Schema.String,
+      authorId: Schema.String,
+      content: Schema.String,
+      mediaUrls: Schema.NullOr(Schema.Array(Schema.String)),
+      replyToId: Schema.NullOr(Schema.String),
+      visibility: Schema.Literal('public', 'followers', 'private'),
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  postEdited: Events.synced({
+    name: 'v1.PostEdited',
+    schema: Schema.Struct({
+      id: Schema.String,
+      content: Schema.String,
+      editedAt: Schema.Date,
+    }),
+  }),
+  
+  postDeleted: Events.synced({
+    name: 'v1.PostDeleted',
+    schema: Schema.Struct({
+      id: Schema.String,
+      deletedAt: Schema.Date,
+    }),
+  }),
+  
+  // Social interaction events
+  followRequested: Events.synced({
+    name: 'v1.FollowRequested',
+    schema: Schema.Struct({
+      followerId: Schema.String,
+      followingId: Schema.String,
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  followApproved: Events.synced({
+    name: 'v1.FollowApproved',
+    schema: Schema.Struct({
+      followerId: Schema.String,
+      followingId: Schema.String,
+      approvedAt: Schema.Date,
+    }),
+  }),
+  
+  unfollowed: Events.synced({
+    name: 'v1.Unfollowed',
+    schema: Schema.Struct({
+      followerId: Schema.String,
+      followingId: Schema.String,
+    }),
+  }),
+  
+  postLiked: Events.synced({
+    name: 'v1.PostLiked',
+    schema: Schema.Struct({
+      userId: Schema.String,
+      postId: Schema.String,
+      createdAt: Schema.Date,
+    }),
+  }),
+  
+  postUnliked: Events.synced({
+    name: 'v1.PostUnliked',
+    schema: Schema.Struct({
+      userId: Schema.String,
+      postId: Schema.String,
+    }),
+  }),
+  
+  // Local UI state
+  feedStateUpdated: tables.feedState.set,
+}
+
+// Materializers with eventual consistency for aggregates
+const materializers = State.SQLite.materializers(events, {
+  // User materializers
+  'v1.UserCreated': ({ id, username, email, displayName, createdAt }) => [
+    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, 
+      mediaUrls: mediaUrls ? JSON.stringify(mediaUrls) : null,
+      replyToId, 
+      visibility, 
+      createdAt 
+    }),
+    tables.postStats.insert({ postId: id, lastUpdated: createdAt }),
+    // Update user post count
+    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({ 
+      followerCount: tables.userStats.select('followerCount').where({ userId: followingId }).scalar() + 1,
+      lastUpdated: approvedAt
+    }).where({ userId: followingId }),
+    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({ 
+      followerCount: Math.max(0, tables.userStats.select('followerCount').where({ userId: followingId }).scalar() - 1),
+      lastUpdated: new Date()
+    }).where({ userId: followingId }),
+    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({ 
+      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({ 
+      likeCount: Math.max(0, tables.postStats.select('likeCount').where({ postId }).scalar() - 1),
+      lastUpdated: new Date()
+    }).where({ postId }),
+  ],
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+
+// Example queries for activity feeds:
+//
+// // Home feed - posts from followed users
+// const homeFeed$ = (userId: string) => queryDb(
+//   tables.posts
+//     .select()
+//     .join(tables.follows, 'authorId', 'followingId')
+//     .join(tables.users, 'authorId', 'id')
+//     .leftJoin(tables.postStats, 'id', 'postId')
+//     .where({ 
+//       followerId: userId, 
+//       'follows.status': 'active',
+//       'posts.deletedAt': null,
+//       'posts.visibility': ['public', 'followers']
+//     })
+//     .orderBy('createdAt', 'desc')
+//     .limit(50),
+//   { label: \`homeFeed-\${userId}\` }
+// )
+//
+// // User profile with stats
+// const userProfile$ = (username: string) => queryDb(
+//   tables.users
+//     .select()
+//     .leftJoin(tables.userStats, 'id', 'userId')
+//     .where({ username }),
+//   { label: \`userProfile-\${username}\` }
+// )`

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

@@ -0,0 +1,171 @@
+export const todoSchemaContent = `import { Events, makeSchema, Schema, SessionIdSymbol, State } from '@livestore/livestore'
+
+// State tables - Define your application state as SQLite tables
+export const tables = {
+  todos: State.SQLite.table({
+    name: 'todos',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      title: State.SQLite.text({ default: '' }),
+      completed: State.SQLite.boolean({ default: false }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      position: State.SQLite.real(), // For ordering - enables conflict-free reordering
+    },
+  }),
+  tags: State.SQLite.table({
+    name: 'tags',
+    columns: {
+      id: State.SQLite.text({ primaryKey: true }),
+      name: State.SQLite.text(),
+      color: State.SQLite.text({ nullable: true }),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+      deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    },
+  }),
+  todoTags: State.SQLite.table({
+    name: 'todo_tags',
+    columns: {
+      todoId: State.SQLite.text(),
+      tagId: State.SQLite.text(),
+      createdAt: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    },
+  }),
+  // Client-only state for UI (not synced)
+  uiState: State.SQLite.clientDocument({
+    name: 'uiState',
+    schema: Schema.Struct({ 
+      newTodoText: Schema.String, 
+      filter: Schema.Literal('all', 'active', 'completed'),
+      selectedTags: Schema.Array(Schema.String)
+    }),
+    default: { id: SessionIdSymbol, value: { newTodoText: '', filter: 'all', selectedTags: [] } },
+  }),
+}
+
+// Events - Define state changes as events for reliable sync and replay
+export const events = {
+  // Todo events
+  todoCreated: Events.synced({
+    name: 'v1.TodoCreated',
+    schema: Schema.Struct({ 
+      id: Schema.String, 
+      title: Schema.String,
+      createdAt: Schema.Date,
+      position: Schema.Number
+    }),
+  }),
+  todoCompleted: Events.synced({
+    name: 'v1.TodoCompleted',
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoUncompleted: Events.synced({
+    name: 'v1.TodoUncompleted', 
+    schema: Schema.Struct({ id: Schema.String }),
+  }),
+  todoTitleChanged: Events.synced({
+    name: 'v1.TodoTitleChanged',
+    schema: Schema.Struct({ id: Schema.String, title: Schema.String }),
+  }),
+  todoReordered: Events.synced({
+    name: 'v1.TodoReordered',
+    schema: Schema.Struct({ id: Schema.String, position: Schema.Number }),
+  }),
+  todoDeleted: Events.synced({
+    name: 'v1.TodoDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  todosCleared: Events.synced({
+    name: 'v1.TodosCleared', 
+    schema: Schema.Struct({ deletedAt: Schema.Date }),
+  }),
+  
+  // Tag events
+  tagCreated: Events.synced({
+    name: 'v1.TagCreated',
+    schema: Schema.Struct({ 
+      id: Schema.String, 
+      name: Schema.String, 
+      color: Schema.NullOr(Schema.String),
+      createdAt: Schema.Date
+    }),
+  }),
+  tagDeleted: Events.synced({
+    name: 'v1.TagDeleted',
+    schema: Schema.Struct({ id: Schema.String, deletedAt: Schema.Date }),
+  }),
+  
+  // Todo-Tag relationship events
+  todoTagged: Events.synced({
+    name: 'v1.TodoTagged',
+    schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String, createdAt: Schema.Date }),
+  }),
+  todoUntagged: Events.synced({
+    name: 'v1.TodoUntagged',
+    schema: Schema.Struct({ todoId: Schema.String, tagId: Schema.String }),
+  }),
+  
+  // UI state events (local only)
+  uiStateSet: tables.uiState.set,
+}
+
+// Materializers - Map events to state changes with conflict-free semantics
+const materializers = State.SQLite.materializers(events, {
+  // Todo materializers
+  'v1.TodoCreated': ({ id, title, createdAt, position }) => 
+    tables.todos.insert({ id, title, completed: false, createdAt, position }),
+    
+  'v1.TodoCompleted': ({ id }) => 
+    tables.todos.update({ completed: true }).where({ id }),
+    
+  'v1.TodoUncompleted': ({ id }) => 
+    tables.todos.update({ completed: false }).where({ id }),
+    
+  'v1.TodoTitleChanged': ({ id, title }) => 
+    tables.todos.update({ title }).where({ id }),
+    
+  'v1.TodoReordered': ({ id, position }) => 
+    tables.todos.update({ position }).where({ id }),
+    
+  'v1.TodoDeleted': ({ id, deletedAt }) => 
+    tables.todos.update({ deletedAt }).where({ id }),
+    
+  'v1.TodosCleared': ({ deletedAt }) => 
+    tables.todos.update({ deletedAt }).where({ completed: true, deletedAt: null }),
+    
+  // Tag materializers  
+  'v1.TagCreated': ({ id, name, color, createdAt }) => 
+    tables.tags.insert({ id, name, color, createdAt }),
+    
+  'v1.TagDeleted': ({ id, deletedAt }) => 
+    tables.tags.update({ deletedAt }).where({ id }),
+    
+  // Todo-Tag relationship materializers
+  'v1.TodoTagged': ({ todoId, tagId, createdAt }) => 
+    tables.todoTags.insert({ todoId, tagId, createdAt }),
+    
+  'v1.TodoUntagged': ({ todoId, tagId }) => 
+    tables.todoTags.delete().where({ todoId, tagId }),
+})
+
+const state = State.SQLite.makeState({ tables, materializers })
+
+export const schema = makeSchema({ events, state })
+
+// Example usage:
+// 
+// import { queryDb, dispatchEvent } from '@livestore/livestore'
+// import { schema, events, tables } from './schema.js'
+//
+// // Query active todos
+// const activeTodos$ = queryDb(
+//   tables.todos.select().where({ deletedAt: null, completed: false }).orderBy('position'),
+//   { label: 'activeTodos' }
+// )
+//
+// // Create a new todo
+// const createTodo = (title: string) => {
+//   const id = crypto.randomUUID()
+//   const position = Date.now() // Simple position strategy
+//   dispatchEvent(events.todoCreated({ id, title, createdAt: new Date(), position }))
+// }`

package/src/mod.ts

@@ -0,0 +1 @@
+export { command as LivestoreCliCommand } from './cli.ts'

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.tsbuildinfo",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}