weifuwu 0.32.1 → 0.33.1

package/dist/base/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Base — dynamic data storage engine for weifuwu.
+ *
+ * Each "base" is a collection of user-defined tables backed by fixed physical slots
+ * (text001..064, number001..032, etc.) mapped through a column_map table.
+ *
+ * Requires `postgres()` and `user()` middleware registered first.
+ *
+ * @example
+ * ```ts
+ * import { serve, Router, postgres, user, base } from 'weifuwu'
+ *
+ * const app = new Router()
+ * app.use(postgres())
+ * app.use(user())
+ * app.use(base())
+ *
+ * // Create a base with tables
+ * app.post('/api/bases', async (req, ctx) => {
+ *   const b = await ctx.base.create(await req.json())
+ *   return Response.json(b, { status: 201 })
+ * })
+ *
+ * // Insert data
+ * app.post('/api/bases/:id/:table', async (req, ctx) => {
+ *   const row = await ctx.base.insert(ctx.params.id, ctx.params.table, await req.json())
+ *   return Response.json(row, { status: 201 })
+ * })
+ *
+ * // Query with filters
+ * app.get('/api/bases/:id/:table', async (req, ctx) => {
+ *   const url = new URL(req.url)
+ *   const filter = url.searchParams.get('filter')
+ *   return Response.json(await ctx.base.query(ctx.params.id, ctx.params.table, {
+ *     filter: filter ? JSON.parse(filter) : undefined,
+ *     limit: parseInt(url.searchParams.get('limit') || '50'),
+ *   }))
+ * })
+ * ```
+ */
+export { Base } from './module.ts';
+export type { BaseAPI, BaseDef, BaseOptions, TableSchema, FieldSchema, FieldType, ColumnMap, CreateBaseInput, UpdateBaseInput, QueryOptions, } from './types.ts';
+import type { Context, Middleware } from '../types.ts';
+import type { BaseAPI, BaseOptions } from './types.ts';
+/**
+ * Base factory — creates the Base instance and returns a middleware
+ * that injects `ctx.base`.
+ *
+ * Must be used **after** `postgres()` and `user()`.
+ *
+ * ```ts
+ * app.use(postgres())
+ * app.use(user())
+ * app.use(base())
+ * ```
+ */
+export declare function base(opts?: BaseOptions): Middleware<Context, Context & {
+    base: BaseAPI;
+}>;

package/dist/base/module.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Base — dynamic data storage engine for weifuwu.
+ *
+ * Each "base" is a collection of user-defined tables with fixed physical slots
+ * (text001..064, number001..032, etc.) mapped via a column_map.
+ *
+ * Depends on `postgres()` and `user()` middleware registered first.
+ *
+ * ```ts
+ * import { serve, Router, postgres, user, base } from 'weifuwu'
+ *
+ * const app = new Router()
+ * app.use(postgres())
+ * app.use(user())
+ * app.use(base())
+ *
+ * app.post('/api/bases', async (req, ctx) => {
+ *   const b = await ctx.base.create(await req.json())
+ *   return Response.json(b, { status: 201 })
+ * })
+ * ```
+ */
+import type { Context, Handler, SqlClient } from '../types.ts';
+import type { BaseAPI, BaseOptions } from './types.ts';
+export declare class Base {
+    private migrated;
+    hasVector: boolean;
+    readonly managementSchema: string;
+    readonly usersTable: string;
+    constructor(opts?: BaseOptions);
+    private ms;
+    migrate(sql: SqlClient): Promise<void>;
+    private ensureMigrated;
+    private allocateSlot;
+    private physicalType;
+    private getColumnMap;
+    private splitFields;
+    private reconstructRow;
+    private buildFilter;
+    bind(ctx: Context): BaseAPI;
+    middleware(req: Request, ctx: Context, next: Handler): Promise<Response>;
+}

package/dist/base/types.d.ts

@@ -0,0 +1,116 @@
+declare module '../types.ts' {
+    interface Context {
+        /** Base module — dynamic data storage engine. */
+        base: import('./types.ts').BaseAPI;
+    }
+}
+export type FieldType = 'string' | 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'vector' | 'search' | 'relation' | 'json';
+export interface FieldSchema {
+    type: FieldType;
+    required?: boolean;
+    unique?: boolean;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    enum?: string[];
+    dimensions?: number;
+    target?: string;
+    description?: string;
+}
+export interface TableSchema {
+    name: string;
+    fields: Record<string, FieldSchema>;
+}
+export interface BaseDef {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    tables: TableSchema[];
+    created_by: string;
+    created_at: Date;
+    updated_at: Date;
+}
+export interface ColumnMap {
+    field_name: string;
+    physical: string;
+    field_type: FieldType;
+}
+export interface CreateBaseInput {
+    name: string;
+    slug?: string;
+    description?: string;
+    tables?: TableSchema[];
+}
+export interface UpdateBaseInput {
+    name?: string;
+    description?: string;
+}
+export interface QueryOptions {
+    filter?: Record<string, unknown>;
+    sort?: string;
+    order?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+    include?: string[];
+}
+export interface BaseOptions {
+    /** Schema name for management tables (default: 'public'). */
+    managementSchema?: string;
+    /** User table name (default: 'users'). */
+    usersTable?: string;
+}
+export interface BaseAPI {
+    /** Create a new base with optional table definitions. */
+    create(input: CreateBaseInput): Promise<BaseDef>;
+    /** List all bases. */
+    list(): Promise<BaseDef[]>;
+    /** Get a base by id. */
+    get(id: string): Promise<BaseDef | null>;
+    /** Get a base by slug. */
+    getBySlug(slug: string): Promise<BaseDef | null>;
+    /** Update base metadata. */
+    update(id: string, input: UpdateBaseInput): Promise<BaseDef | null>;
+    /** Delete a base and all its data. */
+    delete(id: string): Promise<boolean>;
+    /** Define a new table in a base. */
+    defineTable(baseId: string, schema: TableSchema): Promise<BaseDef>;
+    /** Update a table's schema (adds new fields, updates metadata). */
+    updateTable(baseId: string, tableName: string, schema: TableSchema): Promise<BaseDef | null>;
+    /** Remove a table and all its data. */
+    removeTable(baseId: string, tableName: string): Promise<BaseDef | null>;
+    /** Insert a row into a table. */
+    insert(baseId: string, table: string, data: Record<string, unknown>): Promise<Record<string, unknown> & {
+        id: string;
+    }>;
+    /** Get a row by id. */
+    getRow(baseId: string, table: string, id: string): Promise<(Record<string, unknown> & {
+        id: string;
+    }) | null>;
+    /** Update a row by id. */
+    updateRow(baseId: string, table: string, id: string, data: Partial<Record<string, unknown>>): Promise<(Record<string, unknown> & {
+        id: string;
+    }) | null>;
+    /** Delete a row by id. */
+    deleteRow(baseId: string, table: string, id: string): Promise<boolean>;
+    /** Query rows with filtering, sorting, and pagination. */
+    query(baseId: string, table: string, opts?: QueryOptions): Promise<(Record<string, unknown> & {
+        id: string;
+    })[]>;
+    /** Vector similarity search. */
+    similaritySearch(baseId: string, table: string, field: string, vector: number[], opts?: {
+        limit?: number;
+    }): Promise<(Record<string, unknown> & {
+        id: string;
+        distance: number;
+    })[]>;
+    /** Full-text search. */
+    search(baseId: string, table: string, field: string, query: string, opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<(Record<string, unknown> & {
+        id: string;
+        rank: number;
+        headline?: string;
+    })[]>;
+}

package/dist/cms/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * CMS — content management module for weifuwu.
+ *
+ * Requires `postgres()` and `user()` middleware registered first.
+ *
+ * @example
+ * ```ts
+ * import { serve, Router, postgres, user, cms, requireRole } from 'weifuwu'
+ *
+ * const app = new Router()
+ * app.use(postgres())
+ * app.use(user())
+ * app.use(cms())
+ *
+ * // Public: list published posts
+ * app.get('/api/posts', async (req, ctx) => {
+ *   const posts = await ctx.cms.list({ type: 'post', status: 'published' })
+ *   return Response.json(posts)
+ * })
+ *
+ * // Public: get single post
+ * app.get('/api/posts/:slug', async (req, ctx) => {
+ *   const post = await ctx.cms.get(ctx.params.slug)
+ *   if (!post) return new Response('Not found', { status: 404 })
+ *   return Response.json(post)
+ * })
+ *
+ * // Admin: create post
+ * app.post('/api/admin/posts', requireRole('admin'), async (req, ctx) => {
+ *   const post = await ctx.cms.create(await req.json())
+ *   return Response.json(post, { status: 201 })
+ * })
+ *
+ * // Admin: update post
+ * app.patch('/api/admin/posts/:id', requireRole('admin'), async (req, ctx) => {
+ *   const post = await ctx.cms.update(ctx.params.id, await req.json())
+ *   if (!post) return new Response('Not found', { status: 404 })
+ *   return Response.json(post)
+ * })
+ *
+ * // Tags
+ * app.get('/api/tags', async (req, ctx) => {
+ *   return Response.json(await ctx.cms.listTags())
+ * })
+ *
+ * serve(app)
+ * ```
+ */
+export { CMS } from './module.ts';
+export type { CMSAPI, CMSOptions, Content, ContentStatus, ContentType, Tag, TagWithCount, CreateContentInput, UpdateContentInput, ListContentOptions, } from './types.ts';
+import type { Context, Middleware } from '../types.ts';
+import type { CMSAPI, CMSOptions } from './types.ts';
+/**
+ * CMS factory — creates the CMS instance and returns a middleware
+ * that injects `ctx.cms`.
+ *
+ * Must be used **after** `postgres()` and `user()`.
+ *
+ * ```ts
+ * app.use(postgres())
+ * app.use(user())
+ * app.use(cms())
+ * ```
+ */
+export declare function cms(opts?: CMSOptions): Middleware<Context, Context & {
+    cms: CMSAPI;
+}>;

package/dist/cms/module.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CMS — content management module for weifuwu.
+ *
+ * Depends on `postgres()` and `user()` middleware registered first.
+ *
+ * ```ts
+ * import { serve, Router, postgres, user, cms } from 'weifuwu'
+ *
+ * const app = new Router()
+ * app.use(postgres())
+ * app.use(user())
+ * app.use(cms())
+ *
+ * app.get('/api/posts', async (req, ctx) => {
+ *   return Response.json(await ctx.cms.list({ type: 'post', status: 'published' }))
+ * })
+ *
+ * app.get('/api/posts/:slug', async (req, ctx) => {
+ *   const post = await ctx.cms.get(ctx.params.slug)
+ *   if (!post) return new Response('Not found', { status: 404 })
+ *   return Response.json(post)
+ * })
+ * ```
+ */
+import type { Context, Handler, SqlClient } from '../types.ts';
+import type { CMSAPI, CMSOptions } from './types.ts';
+export declare class CMS {
+    private migrated;
+    private prefix;
+    private usersTable;
+    constructor(opts?: CMSOptions);
+    private q;
+    migrate(sql: SqlClient): Promise<void>;
+    private ensureMigrated;
+    bind(ctx: Context): CMSAPI;
+    private _uniqueSlug;
+    middleware(req: Request, ctx: Context, next: Handler): Promise<Response>;
+}

package/dist/cms/types.d.ts

@@ -0,0 +1,96 @@
+declare module '../types.ts' {
+    interface Context {
+        /** CMS instance for content management. */
+        cms: import('./types.ts').CMSAPI;
+    }
+}
+export type ContentStatus = 'draft' | 'published' | 'archived';
+export type ContentType = string;
+export interface Content {
+    id: string;
+    slug: string;
+    type: ContentType;
+    parent_id: string | null;
+    title: string;
+    body: string;
+    excerpt: string | null;
+    cover_image: string | null;
+    status: ContentStatus;
+    author_id: string;
+    author_name?: string;
+    published_at: Date | null;
+    created_at: Date;
+    updated_at: Date;
+    tags?: Tag[];
+}
+export interface Tag {
+    id: string;
+    name: string;
+    slug: string;
+}
+export interface TagWithCount extends Tag {
+    content_count: number;
+}
+export interface CreateContentInput {
+    slug?: string;
+    type: ContentType;
+    parent_id?: string;
+    title: string;
+    body: string;
+    excerpt?: string;
+    cover_image?: string;
+    status?: ContentStatus;
+    tags?: string[];
+}
+export interface UpdateContentInput {
+    slug?: string;
+    type?: ContentType;
+    parent_id?: string | null;
+    title?: string;
+    body?: string;
+    excerpt?: string | null;
+    cover_image?: string | null;
+    status?: ContentStatus;
+    tags?: string[];
+}
+export interface ListContentOptions {
+    type?: ContentType;
+    status?: ContentStatus;
+    tag?: string;
+    author_id?: string;
+    parent_id?: string | null;
+    /** Cursor pagination: return items before this cursor (created_at DESC). */
+    before?: string;
+    /** Page size (default: 20, max: 100). */
+    limit?: number;
+}
+export interface CMSOptions {
+    /** PostgreSQL table prefix (default: ''). */
+    tablePrefix?: string;
+    /** User table name for author name lookups (default: 'users'). */
+    usersTable?: string;
+}
+export interface CMSAPI {
+    /** List content with filters and cursor pagination. */
+    list(opts?: ListContentOptions): Promise<Content[]>;
+    /** Get a single content by slug. Returns null if not found or not published (for non-admin). */
+    get(slug: string): Promise<Content | null>;
+    /** Get a single content by id. */
+    getById(id: string): Promise<Content | null>;
+    /** Create content. Requires admin role. */
+    create(input: CreateContentInput): Promise<Content>;
+    /** Update content. Requires admin role. Returns null if not found. */
+    update(id: string, input: UpdateContentInput): Promise<Content | null>;
+    /** Delete content (hard delete). Requires admin role. */
+    delete(id: string): Promise<boolean>;
+    /** Publish content (set status to 'published' and set published_at). */
+    publish(id: string): Promise<Content | null>;
+    /** Unpublish content (set status to 'draft'). */
+    unpublish(id: string): Promise<Content | null>;
+    /** List all tags with content count. */
+    listTags(): Promise<TagWithCount[]>;
+    /** Create a tag. */
+    createTag(name: string): Promise<Tag>;
+    /** Delete a tag. */
+    deleteTag(id: string): Promise<boolean>;
+}

package/dist/index.d.ts

@@ -11,8 +11,6 @@ export { logger } from './core/logger.ts';
 export type { LoggerOptions } from './core/logger.ts';
 export { cors } from './middleware/cors.ts';
 export type { CORSOptions } from './middleware/cors.ts';
-export { auth } from './middleware/auth.ts';
-export type { AuthOptions } from './middleware/auth.ts';
 export { serveStatic } from './middleware/static.ts';
 export type { ServeStaticOptions } from './middleware/static.ts';
 export { upload } from './middleware/upload.ts';
@@ -39,10 +37,18 @@ export { createHub } from './hub.ts';
 export type { Hub, HubOptions } from './hub.ts';
 export { queue } from './queue/index.ts';
 export type { QueueOptions, QueueJob, Queue, QueueInjected } from './queue/types.ts';
-export { react, reactRouter } from './react/index.ts';
-export type { ReactOptions, RenderOptions, ReactRouterOptions, ReactAppOptions } from './react/types.ts';
-export { useServerData, ServerDataContext, Link, ErrorBoundary } from './react/index.ts';
 export { ai } from './ai/index.ts';
 export type { AiOptions, Ai } from './ai/index.ts';
 export { agent } from './ai/agent.ts';
 export type { AgentOptions, Agent } from './ai/agent.ts';
+export { user, UserModule } from './user/index.ts';
+export type { UserModuleOptions, UserRecord, CreateUserInput, UpdateUserInput, TokenPayload, } from './user/types.ts';
+export { messager, Messager } from './messager/index.ts';
+export type { MessagerAPI, MessagerOptions, Conversation, ConversationType, Participant, ParticipantUser, Message, MessagePreview, } from './messager/types.ts';
+export { base, Base } from './base/index.ts';
+export { cms, CMS } from './cms/index.ts';
+export type { CMSAPI, CMSOptions, Content, ContentStatus, ContentType, Tag, TagWithCount, CreateContentInput, UpdateContentInput, ListContentOptions, } from './cms/types.ts';
+export { kb, KB } from './kb/index.ts';
+export type { KBAPI, KBOptions, Document, Chunk, SearchResult, ImportOptions, SearchOptions, } from './kb/types.ts';
+export type { BaseAPI, BaseDef, BaseOptions, TableSchema, FieldSchema, FieldType, ColumnMap, CreateBaseInput, UpdateBaseInput, QueryOptions, } from './base/types.ts';
+export { requireRole } from './user/types.ts';