zilmate 1.7.8 → 1.8.0

package/.agents/skills/neon-drizzle/scripts/generate-schema.ts

@@ -0,0 +1,77 @@
+/**
+ * Generate Schema Script
+ *
+ * Generates Drizzle migration files based on schema changes.
+ * Run with: npx drizzle-kit generate
+ *
+ * This creates SQL migration files in the migrations directory
+ * based on differences between your schema.ts and the database.
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function generateSchema() {
+  console.log('🔄 Generating Drizzle migrations...\n');
+
+  try {
+    const { stdout, stderr } = await execAsync('npx drizzle-kit generate');
+
+    if (stdout) {
+      console.log('📝 Generated migrations:');
+      console.log(stdout);
+    }
+
+    if (stderr) {
+      console.warn('⚠️  Warnings:');
+      console.warn(stderr);
+    }
+
+    console.log('\n✅ Migration generation complete!');
+    console.log('\n📋 Next steps:');
+    console.log('   1. Review the generated migration files in ./src/db/migrations');
+    console.log('   2. Run: npx drizzle-kit migrate');
+    console.log('   3. Test your application\n');
+
+    return true;
+  } catch (error) {
+    console.error('❌ Migration generation failed');
+    console.error((error as any).message);
+
+    console.log('\n💡 Troubleshooting:');
+    console.log('   • Ensure drizzle.config.ts is in your project root');
+    console.log('   • Check that DATABASE_URL is set correctly');
+    console.log('   • Verify your schema.ts file exists at the configured path');
+    console.log('   • Review guides/troubleshooting.md for common issues');
+    console.log('   • See references/migrations.md for migration patterns');
+
+    const errorMessage = (error as any).message.toLowerCase();
+
+    if (errorMessage.includes('url') || errorMessage.includes('undefined')) {
+      console.log('\n⚠️  Environment variable issue detected:');
+      console.log('   • Ensure DATABASE_URL is loaded in drizzle.config.ts');
+      console.log('   • Add: import { config } from "dotenv"; config({ path: ".env.local" });');
+      console.log('   • See guides/troubleshooting.md section: "Error: url: undefined"');
+    }
+
+    if (errorMessage.includes('schema') || errorMessage.includes('not found')) {
+      console.log('\n⚠️  Schema file issue detected:');
+      console.log('   • Verify schema path in drizzle.config.ts matches actual file location');
+      console.log('   • Default: ./src/db/schema.ts');
+    }
+
+    if (errorMessage.includes('enoent')) {
+      console.log('\n⚠️  File/directory missing:');
+      console.log('   • Create migrations folder: mkdir -p src/db/migrations');
+      console.log('   • Ensure schema file exists: src/db/schema.ts');
+    }
+
+    return false;
+  }
+}
+
+generateSchema().then((success) => {
+  process.exit(success ? 0 : 1);
+});

package/.agents/skills/neon-drizzle/scripts/run-migration.ts

@@ -0,0 +1,133 @@
+/**
+ * Run Migration Script
+ *
+ * Applies pending Drizzle migrations to your Neon database.
+ * Run with: npx ts-node run-migration.ts
+ *
+ * This script will:
+ * 1. Connect to your Neon database
+ * 2. Apply all pending migrations
+ * 3. Report success or failure
+ */
+
+import { drizzle } from 'drizzle-orm/neon-http';
+import { migrate } from 'drizzle-orm/neon-http/migrator';
+import { neon } from '@neondatabase/serverless';
+
+const DATABASE_URL = process.env.DATABASE_URL;
+
+if (!DATABASE_URL) {
+  console.error('❌ DATABASE_URL environment variable is not set');
+  process.exit(1);
+}
+
+async function runMigrations() {
+  console.log('🔄 Running Drizzle migrations...\n');
+
+  try {
+    // Create SQL client
+    const sql = neon(DATABASE_URL);
+
+    // Create Drizzle instance
+    const db = drizzle(sql);
+
+    // Run migrations
+    console.log('⏳ Applying migrations...');
+    await migrate(db, {
+      migrationsFolder: './src/db/migrations',
+    });
+
+    console.log('✅ All migrations applied successfully!\n');
+
+    // Show migration status
+    console.log('📊 Migration Summary:');
+    console.log('   Database: ' + new URL(DATABASE_URL).pathname.slice(1));
+    console.log('   Migrations folder: ./src/db/migrations');
+    console.log('   Status: Up to date\n');
+
+    return true;
+  } catch (error) {
+    console.error('❌ Migration failed');
+    console.error((error as any).message);
+
+    console.log('\n💡 Troubleshooting:');
+    console.log('   • Ensure ./src/db/migrations directory exists');
+    console.log('   • Verify DATABASE_URL is correct');
+    console.log('   • Check that migrations are properly formatted SQL files');
+    console.log('   • Try running: npx drizzle-kit generate first');
+    console.log('   • Review guides/troubleshooting.md for common migration errors');
+    console.log('   • See references/migrations.md for detailed migration guide');
+
+    const errorMessage = (error as any).message.toLowerCase();
+
+    if (errorMessage.includes('connect') || errorMessage.includes('connection')) {
+      console.log('\n⚠️  Connection issue detected:');
+      console.log('   • Verify DATABASE_URL format: postgresql://user:pass@host/db?sslmode=require');
+      console.log('   • Ensure database is accessible');
+      console.log('   • Check firewall/network settings');
+      console.log('   • See guides/troubleshooting.md section: "Connection Errors"');
+    }
+
+    if (errorMessage.includes('already exists') || errorMessage.includes('duplicate')) {
+      console.log('\n⚠️  Migration conflict detected:');
+      console.log('   • Migration may have been partially applied');
+      console.log('   • Check database state: psql $DATABASE_URL -c "\\dt"');
+      console.log('   • See references/migrations.md for handling conflicts');
+    }
+
+    if (errorMessage.includes('not found') || errorMessage.includes('enoent')) {
+      console.log('\n⚠️  Migrations folder missing:');
+      console.log('   • Run: npx drizzle-kit generate');
+      console.log('   • Ensure migrations folder path matches drizzle.config.ts');
+    }
+
+    if (errorMessage.includes('syntax')) {
+      console.log('\n⚠️  SQL syntax error:');
+      console.log('   • Review generated migration files in ./src/db/migrations');
+      console.log('   • Check for manually edited migrations');
+      console.log('   • See references/migrations.md for safe editing practices');
+    }
+
+    console.log('');
+    return false;
+  }
+}
+
+/**
+ * Alternative: Run migrations with WebSocket (for Node.js)
+ * Uncomment below if using WebSocket connections
+ */
+
+/*
+import { drizzle } from 'drizzle-orm/neon-serverless';
+import { migrate } from 'drizzle-orm/neon-serverless/migrator';
+import { Pool } from '@neondatabase/serverless';
+
+async function runMigrationsWebSocket() {
+  console.log('🔄 Running Drizzle migrations (WebSocket)...\n');
+
+  const pool = new Pool({ connectionString: DATABASE_URL });
+
+  try {
+    const db = drizzle(pool);
+
+    console.log('⏳ Applying migrations...');
+    await migrate(db, {
+      migrationsFolder: './src/db/migrations',
+    });
+
+    console.log('✅ All migrations applied successfully!\n');
+    await pool.end();
+    return true;
+  } catch (error) {
+    console.error('❌ Migration failed:', (error as any).message);
+    await pool.end();
+    return false;
+  }
+}
+*/
+
+// Run migrations
+runMigrations().then((success) => {
+  process.exit(success ? 0 : 1);
+});

package/.agents/skills/neon-drizzle/templates/db-http.ts

@@ -0,0 +1,6 @@
+import { drizzle } from 'drizzle-orm/neon-http';
+import { neon } from '@neondatabase/serverless';
+
+const sql = neon(process.env.DATABASE_URL!);
+
+export const db = drizzle(sql);

package/.agents/skills/neon-drizzle/templates/db-websocket.ts

@@ -0,0 +1,24 @@
+import { drizzle } from 'drizzle-orm/neon-serverless';
+import { Pool, neonConfig } from '@neondatabase/serverless';
+import ws from 'ws';
+
+neonConfig.webSocketConstructor = ws;
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL!,
+  max: 10,
+  idleTimeoutMillis: 30000,
+  connectionTimeoutMillis: 5000,
+});
+
+export const db = drizzle(pool);
+
+process.on('SIGTERM', async () => {
+  await pool.end();
+  process.exit(0);
+});
+
+process.on('SIGINT', async () => {
+  await pool.end();
+  process.exit(0);
+});

package/.agents/skills/neon-drizzle/templates/drizzle-config.ts

@@ -0,0 +1,96 @@
+/**
+ * Drizzle Configuration
+ *
+ * This file configures Drizzle ORM for use with Neon.
+ * Place this in your project root or src/ directory.
+ *
+ * Usage: Reference this in your drizzle.config.ts
+ */
+
+import { config } from 'dotenv';
+import type { Config } from 'drizzle-kit';
+
+config({ path: '.env.local' });
+
+/**
+ * Drizzle Configuration for Neon Postgres
+ *
+ * Supports both HTTP and WebSocket connections.
+ * Automatically detects which driver to use based on environment.
+ */
+
+const dbUrl = process.env.DATABASE_URL;
+
+if (!dbUrl) {
+  throw new Error('DATABASE_URL environment variable is not set');
+}
+
+// Determine connection type based on environment
+const isServerless = process.env.RUNTIME === 'edge' ||
+                    process.env.VERCEL_ENV === 'production';
+
+export default {
+  schema: './src/db/schema.ts', // Path to your schema file
+  out: './src/db/migrations', // Output directory for migrations
+
+  // Database connection
+  dbCredentials: {
+    url: dbUrl,
+  },
+
+  // Migration options
+  migrations: {
+    prefix: 'timestamp', // or 'none'
+  },
+
+  // Verbose logging for debugging
+  verbose: process.env.DEBUG === 'true',
+
+  // Strict mode ensures all migrations are applied
+  strict: true,
+} satisfies Config;
+
+/**
+ * HTTP Connection Configuration (for Vercel Edge, etc.)
+ *
+ * export default {
+ *   schema: './src/db/schema.ts',
+ *   out: './src/db/migrations',
+ *   driver: 'postgres',
+ *   dbCredentials: {
+ *     url: process.env.DATABASE_URL!,
+ *   },
+ * } satisfies Config;
+ */
+
+/**
+ * WebSocket Connection Configuration (for Node.js servers)
+ *
+ * export default {
+ *   schema: './src/db/schema.ts',
+ *   out: './src/db/migrations',
+ *   driver: 'pg',
+ *   dbCredentials: {
+ *     url: process.env.DATABASE_URL!,
+ *   },
+ * } satisfies Config;
+ */
+
+/**
+ * Migration Commands
+ *
+ * # Generate migration files from schema changes
+ * npx drizzle-kit generate
+ *
+ * # Apply migrations to database
+ * npx drizzle-kit migrate
+ *
+ * # Drop all tables (careful!)
+ * npx drizzle-kit drop
+ *
+ * # Introspect existing database
+ * npx drizzle-kit introspect
+ *
+ * # Push schema changes directly (development only)
+ * npx drizzle-kit push
+ */

package/.agents/skills/neon-drizzle/templates/schema-example.ts

@@ -0,0 +1,231 @@
+/**
+ * Drizzle Schema Example
+ *
+ * This file demonstrates how to define database tables and relationships
+ * using Drizzle ORM with Neon Postgres.
+ *
+ * Usage: Import these tables in your application code for type-safe queries
+ */
+
+import {
+  pgTable,
+  serial,
+  text,
+  varchar,
+  integer,
+  timestamp,
+  boolean,
+  decimal,
+  json,
+  index,
+  unique,
+  foreignKey,
+} from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+
+/**
+ * Users Table
+ *
+ * Stores basic user information. Can be extended with additional fields
+ * as needed by your application.
+ */
+export const users = pgTable(
+  'users',
+  {
+    id: serial('id').primaryKey(),
+    email: varchar('email', { length: 255 }).notNull().unique(),
+    name: varchar('name', { length: 255 }).notNull(),
+    password: text('password'), // If not using external auth
+    avatar: text('avatar'), // URL to avatar image
+    isActive: boolean('is_active').default(true),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow(),
+  },
+  (table) => ({
+    emailIdx: index('users_email_idx').on(table.email),
+    createdAtIdx: index('users_created_at_idx').on(table.createdAt),
+  })
+);
+
+/**
+ * Profiles Table
+ *
+ * Extended user information. Uses a foreign key to link with users.
+ */
+export const profiles = pgTable('profiles', {
+  id: serial('id').primaryKey(),
+  userId: integer('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  bio: text('bio'),
+  location: varchar('location', { length: 255 }),
+  website: varchar('website', { length: 255 }),
+  phone: varchar('phone', { length: 20 }),
+  createdAt: timestamp('created_at').defaultNow(),
+  updatedAt: timestamp('updated_at').defaultNow(),
+});
+
+/**
+ * Posts Table
+ *
+ * Blog posts created by users.
+ */
+export const posts = pgTable(
+  'posts',
+  {
+    id: serial('id').primaryKey(),
+    userId: integer('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    title: varchar('title', { length: 255 }).notNull(),
+    slug: varchar('slug', { length: 255 }).notNull().unique(),
+    content: text('content').notNull(),
+    excerpt: text('excerpt'),
+    published: boolean('published').default(false),
+    publishedAt: timestamp('published_at'),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow(),
+  },
+  (table) => ({
+    userIdIdx: index('posts_user_id_idx').on(table.userId),
+    publishedIdx: index('posts_published_idx').on(table.published),
+    slugIdx: index('posts_slug_idx').on(table.slug),
+  })
+);
+
+/**
+ * Comments Table
+ *
+ * Comments on blog posts. Supports nested comments via parent_id.
+ */
+export const comments = pgTable(
+  'comments',
+  {
+    id: serial('id').primaryKey(),
+    postId: integer('post_id')
+      .notNull()
+      .references(() => posts.id, { onDelete: 'cascade' }),
+    userId: integer('user_id')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    parentId: integer('parent_id').references(() => comments.id, {
+      onDelete: 'cascade',
+    }),
+    content: text('content').notNull(),
+    approved: boolean('approved').default(false),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow(),
+  },
+  (table) => ({
+    postIdIdx: index('comments_post_id_idx').on(table.postId),
+    userIdIdx: index('comments_user_id_idx').on(table.userId),
+    parentIdIdx: index('comments_parent_id_idx').on(table.parentId),
+  })
+);
+
+/**
+ * Tags Table
+ *
+ * Tags for categorizing posts.
+ */
+export const tags = pgTable('tags', {
+  id: serial('id').primaryKey(),
+  name: varchar('name', { length: 100 }).notNull().unique(),
+  slug: varchar('slug', { length: 100 }).notNull().unique(),
+  createdAt: timestamp('created_at').defaultNow(),
+});
+
+/**
+ * PostTags Junction Table
+ *
+ * Many-to-many relationship between posts and tags.
+ */
+export const postTags = pgTable(
+  'post_tags',
+  {
+    postId: integer('post_id')
+      .notNull()
+      .references(() => posts.id, { onDelete: 'cascade' }),
+    tagId: integer('tag_id')
+      .notNull()
+      .references(() => tags.id, { onDelete: 'cascade' }),
+  },
+  (table) => ({
+    pk: { name: 'post_tags_pk', columns: [table.postId, table.tagId] },
+    postIdIdx: index('post_tags_post_id_idx').on(table.postId),
+    tagIdIdx: index('post_tags_tag_id_idx').on(table.tagId),
+  })
+);
+
+/**
+ * Settings Table
+ *
+ * Application-wide or user-specific settings stored as JSON.
+ */
+export const settings = pgTable('settings', {
+  id: serial('id').primaryKey(),
+  userId: integer('user_id').references(() => users.id, {
+    onDelete: 'cascade',
+  }), // null = global settings
+  key: varchar('key', { length: 255 }).notNull(),
+  value: json('value'),
+  createdAt: timestamp('created_at').defaultNow(),
+  updatedAt: timestamp('updated_at').defaultNow(),
+});
+
+// ============================================================================
+// Relations (optional but recommended for better type safety)
+// ============================================================================
+
+export const usersRelations = relations(users, ({ many, one }) => ({
+  profile: one(profiles),
+  posts: many(posts),
+  comments: many(comments),
+}));
+
+export const profilesRelations = relations(profiles, ({ one }) => ({
+  user: one(users, {
+    fields: [profiles.userId],
+    references: [users.id],
+  }),
+}));
+
+export const postsRelations = relations(posts, ({ one, many }) => ({
+  author: one(users, {
+    fields: [posts.userId],
+    references: [users.id],
+  }),
+  comments: many(comments),
+  tags: many(postTags),
+}));
+
+export const commentsRelations = relations(comments, ({ one, many }) => ({
+  post: one(posts, {
+    fields: [comments.postId],
+    references: [posts.id],
+  }),
+  author: one(users, {
+    fields: [comments.userId],
+    references: [users.id],
+  }),
+  parent: one(comments, {
+    fields: [comments.parentId],
+    references: [comments.id],
+  }),
+  replies: many(comments),
+}));
+
+export const tagsRelations = relations(tags, ({ many }) => ({
+  posts: many(postTags),
+}));
+
+export const postTagsRelations = relations(postTags, ({ one }) => ({
+  post: one(posts, {
+    fields: [postTags.postId],
+    references: [posts.id],
+  }),
+  tag: one(tags, {
+    fields: [postTags.tagId],
+    references: [tags.id],
+  }),
+}));