@nuraly/lumenjs 0.1.3 → 0.1.4

package/dist/email/types.d.ts

@@ -0,0 +1,49 @@
+export interface TemplateData {
+    appName: string;
+    url: string;
+    userName?: string;
+    email?: string;
+    loginUrl?: string;
+    /** Arbitrary extra data for custom templates (arrays, objects, etc.) */
+    [key: string]: any;
+}
+export type TemplateRenderer = (data: TemplateData) => string;
+export interface EmailTemplates {
+    'verify-email'?: TemplateRenderer;
+    'password-reset'?: TemplateRenderer;
+    'welcome'?: TemplateRenderer;
+    [key: string]: TemplateRenderer | undefined;
+}
+export interface EmailConfig {
+    provider: 'smtp' | 'resend' | 'sendgrid';
+    from: string;
+    smtp?: {
+        host: string;
+        port: number;
+        secure?: boolean;
+        rejectUnauthorized?: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+    };
+    resend?: {
+        apiKey: string;
+    };
+    sendgrid?: {
+        apiKey: string;
+    };
+    /** Custom email templates. Override built-in templates or add new ones. */
+    templates?: EmailTemplates;
+}
+export interface EmailMessage {
+    to: string;
+    subject: string;
+    html: string;
+    text?: string;
+}
+export interface EmailProvider {
+    send(message: EmailMessage & {
+        from: string;
+    }): Promise<void>;
+}

package/dist/email/types.js

@@ -0,0 +1 @@
+export {};

package/dist/llms/generate.d.ts

@@ -0,0 +1,46 @@
+export interface LlmsPage {
+    path: string;
+    hasLoader: boolean;
+    hasSubscribe: boolean;
+    loaderData?: any;
+    dynamicEntries?: {
+        path: string;
+        loaderData: any;
+    }[];
+}
+export interface LlmsApiRoute {
+    path: string;
+    methods: string[];
+}
+export interface LlmsTxtInput {
+    title: string;
+    pages: LlmsPage[];
+    apiRoutes: LlmsApiRoute[];
+    integrations: string[];
+    i18n?: {
+        locales: string[];
+        defaultLocale: string;
+    };
+    db?: {
+        path?: string;
+    };
+}
+/**
+ * Generate the llms.txt content from project metadata and resolved page data.
+ */
+export declare function generateLlmsTxt(input: LlmsTxtInput): string;
+/**
+ * Try to resolve dynamic route entries by finding a parent/sibling index page
+ * whose loader returns an array, then calling the dynamic page's loader for each item.
+ */
+export declare function resolveDynamicEntries(dynamicPage: {
+    path: string;
+    paramName: string;
+}, loadModule: (filePath: string) => Promise<any>, pages: {
+    path: string;
+    filePath: string;
+    hasLoader: boolean;
+}[]): Promise<{
+    path: string;
+    loaderData: any;
+}[] | null>;

package/dist/llms/generate.js

@@ -0,0 +1,185 @@
+/**
+ * Generate the llms.txt content from project metadata and resolved page data.
+ */
+export function generateLlmsTxt(input) {
+    const lines = [];
+    lines.push(`# ${input.title}`);
+    lines.push('');
+    lines.push('> Built with LumenJS');
+    lines.push('');
+    // Pages section
+    if (input.pages.length > 0) {
+        lines.push('## Pages');
+        lines.push('');
+        for (const page of input.pages) {
+            lines.push(`### ${page.path}`);
+            const isDynamic = page.path.includes(':');
+            if (isDynamic) {
+                // Dynamic route — show expanded entries if available
+                if (page.dynamicEntries && page.dynamicEntries.length > 0) {
+                    lines.push(`Dynamic route — ${page.dynamicEntries.length} ${page.dynamicEntries.length === 1 ? 'entry' : 'entries'}:`);
+                    lines.push('');
+                    for (const entry of page.dynamicEntries) {
+                        lines.push(`#### ${entry.path}`);
+                        if (entry.loaderData) {
+                            lines.push(flattenData(entry.loaderData));
+                        }
+                        lines.push('');
+                    }
+                }
+                else {
+                    lines.push('- Dynamic route');
+                    lines.push('');
+                }
+            }
+            else if (page.loaderData && typeof page.loaderData === 'object') {
+                // Static page with loader data
+                lines.push(flattenData(page.loaderData));
+                lines.push('');
+            }
+            else {
+                // Simple page
+                const features = [];
+                if (page.hasLoader)
+                    features.push('with loader data');
+                if (page.hasSubscribe)
+                    features.push('with live data');
+                lines.push(`- Server-rendered page${features.length ? ' ' + features.join(', ') : ''}`);
+                lines.push('');
+            }
+        }
+    }
+    // API Routes section
+    if (input.apiRoutes.length > 0) {
+        lines.push('## API Routes');
+        lines.push('');
+        for (const route of input.apiRoutes) {
+            for (const method of route.methods) {
+                lines.push(`- ${method} /api/${route.path}`);
+            }
+        }
+        lines.push('');
+    }
+    // Features section
+    const features = [];
+    if (input.db)
+        features.push('SQLite Database');
+    if (input.i18n) {
+        features.push(`Internationalization (${input.i18n.locales.join(', ')})`);
+    }
+    for (const integration of input.integrations) {
+        if (integration === 'tailwind')
+            features.push('Tailwind CSS');
+        else if (integration === 'nuralyui')
+            features.push('NuralyUI Components');
+        else
+            features.push(integration);
+    }
+    if (features.length > 0) {
+        lines.push('## Features');
+        lines.push('');
+        for (const feature of features) {
+            lines.push(`- ${feature}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd() + '\n';
+}
+/**
+ * Flatten a loader data object into key-value text lines.
+ */
+function flattenData(data, prefix = '') {
+    if (data == null)
+        return '';
+    if (typeof data !== 'object')
+        return `${prefix}${String(data)}`;
+    // If it's an array, skip it (arrays are for lists, not flat display)
+    if (Array.isArray(data))
+        return '';
+    const lines = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (value == null)
+            continue;
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            lines.push(flattenData(value, `${prefix}${key}.`));
+        }
+        else if (Array.isArray(value)) {
+            // Skip arrays in flat display
+            continue;
+        }
+        else {
+            const strVal = String(value);
+            // Truncate very long values
+            const displayVal = strVal.length > 300 ? strVal.slice(0, 300) + '...' : strVal;
+            lines.push(`${prefix}${key}: ${displayVal}`);
+        }
+    }
+    return lines.filter(Boolean).join('\n');
+}
+/**
+ * Try to resolve dynamic route entries by finding a parent/sibling index page
+ * whose loader returns an array, then calling the dynamic page's loader for each item.
+ */
+export async function resolveDynamicEntries(dynamicPage, loadModule, pages) {
+    // Extract the parent path from the dynamic route
+    // e.g., /blog/:slug -> /blog, /docs/:id -> /docs
+    const segments = dynamicPage.path.split('/');
+    segments.pop(); // remove the dynamic segment
+    const parentPath = segments.join('/') || '/';
+    // Find parent or sibling index page with a loader
+    const indexPage = pages.find(p => p.hasLoader && (p.path === parentPath || p.path === parentPath + '/'));
+    if (!indexPage)
+        return null;
+    try {
+        const indexMod = await loadModule(indexPage.filePath);
+        if (!indexMod?.loader)
+            return null;
+        const indexData = await indexMod.loader({ params: {}, query: {}, url: indexPage.path, headers: {} });
+        if (!indexData || typeof indexData !== 'object')
+            return null;
+        // Find the array in the loader data (look for the first array value)
+        let items = null;
+        for (const value of Object.values(indexData)) {
+            if (Array.isArray(value)) {
+                items = value;
+                break;
+            }
+        }
+        // If the returned data is itself an array
+        if (!items && Array.isArray(indexData)) {
+            items = indexData;
+        }
+        if (!items || items.length === 0)
+            return null;
+        // For each item, try to call the dynamic page's loader
+        const dynamicMod = await loadModule(pages.find(p => p.path === dynamicPage.path)?.filePath || '');
+        if (!dynamicMod?.loader)
+            return null;
+        const entries = [];
+        for (const item of items) {
+            // Try to extract the param value from the item
+            const paramValue = item[dynamicPage.paramName] || item.slug || item.id || item.name;
+            if (!paramValue)
+                continue;
+            try {
+                const loaderData = await dynamicMod.loader({
+                    params: { [dynamicPage.paramName]: String(paramValue) },
+                    query: {},
+                    url: dynamicPage.path.replace(`:${dynamicPage.paramName}`, String(paramValue)),
+                    headers: {},
+                });
+                if (loaderData) {
+                    const resolvedPath = dynamicPage.path.replace(`:${dynamicPage.paramName}`, String(paramValue));
+                    entries.push({ path: resolvedPath, loaderData });
+                }
+            }
+            catch {
+                // Skip items whose loader fails
+            }
+        }
+        return entries.length > 0 ? entries : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/permissions/guard.d.ts

@@ -0,0 +1,28 @@
+import type { AuthUser } from '../auth/types.js';
+import type { PermissionService } from './service.js';
+export type GuardResult = {
+    allowed: true;
+} | {
+    redirect: string;
+} | {
+    forbidden: true;
+};
+/**
+ * Enforce a permission guard on a page.
+ *
+ * Called when a page exports:
+ *   export const auth = { permission: 'workflow:read', resourceParam: 'workflowId' };
+ *
+ * Checks authentication first, then resource-level permission.
+ */
+export declare function enforcePermissionGuard(authExport: {
+    permission: string;
+    resourceParam: string;
+}, user: AuthUser | null | undefined, loginUrl: string, pathname: string, urlParams: Record<string, string>, permissionService: PermissionService): Promise<GuardResult>;
+/**
+ * Check if an auth export contains a permission guard (has 'permission' field).
+ */
+export declare function isPermissionGuard(authExport: any): authExport is {
+    permission: string;
+    resourceParam: string;
+};

package/dist/permissions/guard.js

@@ -0,0 +1,30 @@
+/**
+ * Enforce a permission guard on a page.
+ *
+ * Called when a page exports:
+ *   export const auth = { permission: 'workflow:read', resourceParam: 'workflowId' };
+ *
+ * Checks authentication first, then resource-level permission.
+ */
+export async function enforcePermissionGuard(authExport, user, loginUrl, pathname, urlParams, permissionService) {
+    // Must be authenticated
+    if (!user) {
+        return { redirect: `${loginUrl}?returnTo=${encodeURIComponent(pathname)}` };
+    }
+    const resourceId = urlParams[authExport.resourceParam];
+    if (!resourceId) {
+        return { allowed: true };
+    }
+    const [resourceType] = authExport.permission.split(':');
+    const hasPermission = await permissionService.canAccess(user.sub, authExport.permission, resourceType, resourceId);
+    if (!hasPermission) {
+        return { forbidden: true };
+    }
+    return { allowed: true };
+}
+/**
+ * Check if an auth export contains a permission guard (has 'permission' field).
+ */
+export function isPermissionGuard(authExport) {
+    return authExport && typeof authExport === 'object' && typeof authExport.permission === 'string';
+}

package/dist/permissions/index.d.ts

@@ -0,0 +1,6 @@
+export { PermissionService, usePermissions } from './service.js';
+export type { AuditLogEntry } from './service.js';
+export { ensurePermissionTables } from './tables.js';
+export { enforcePermissionGuard, isPermissionGuard } from './guard.js';
+export type { GuardResult } from './guard.js';
+export type { ResourcePermission, Role, UserRole, PermissionsConfig, ResolvedPermissionsConfig, } from './types.js';

package/dist/permissions/index.js

@@ -0,0 +1,3 @@
+export { PermissionService, usePermissions } from './service.js';
+export { ensurePermissionTables } from './tables.js';
+export { enforcePermissionGuard, isPermissionGuard } from './guard.js';

package/dist/permissions/service.d.ts

@@ -0,0 +1,80 @@
+import type { ResourcePermission, ResolvedPermissionsConfig } from './types.js';
+export interface AuditLogEntry {
+    id: number;
+    action: string;
+    resource_type: string | null;
+    resource_id: string | null;
+    grantee_type: string | null;
+    grantee_id: string | null;
+    permission: string | null;
+    role_id: string | null;
+    actor_id: string;
+    details: string | null;
+    created_at: string;
+}
+export declare class PermissionService {
+    private db;
+    private config;
+    constructor(db: any, config?: Partial<ResolvedPermissionsConfig>);
+    private audit;
+    /**
+     * Query audit log entries.
+     */
+    getAuditLog(opts?: {
+        resourceType?: string;
+        resourceId?: string;
+        actorId?: string;
+        limit?: number;
+    }): Promise<AuditLogEntry[]>;
+    /**
+     * Check if a user can perform an action on a resource.
+     *
+     * Check order:
+     * 1. Direct user grant
+     * 2. Public grant (anyone with the link)
+     * 3. Anonymous grant (only if anonymous flag set)
+     * 4. Role-based permissions (global roles, then resource-scoped roles)
+     * 5. Wildcard '*' permission matches any action
+     */
+    canAccess(userId: string | null, permissionType: string, resourceType: string, resourceId: string, anonymous?: boolean): Promise<boolean>;
+    /**
+     * Get all resource IDs of a given type that a user can access.
+     */
+    getAccessibleResourceIds(userId: string, resourceType: string, permission: string): Promise<string[]>;
+    /**
+     * Get all permissions for a resource.
+     */
+    getPermissionsForResource(resourceType: string, resourceId: string): Promise<ResourcePermission[]>;
+    /**
+     * Initialize owner permissions when a resource is created.
+     */
+    initOwnerPermissions(resourceType: string, resourceId: string, userId: string): Promise<void>;
+    /**
+     * Grant a permission on a resource.
+     */
+    grant(resourceType: string, resourceId: string, granteeType: string, granteeId: string | null, permission: string, grantedBy: string): Promise<void>;
+    /**
+     * Revoke a permission on a resource.
+     */
+    revoke(resourceType: string, resourceId: string, granteeType: string, granteeId: string | null, permission: string, revokedBy: string): Promise<void>;
+    /**
+     * Make a resource publicly accessible (read).
+     */
+    makePublic(resourceType: string, resourceId: string, grantedBy: string): Promise<void>;
+    /**
+     * Remove public access from a resource.
+     */
+    removePublic(resourceType: string, resourceId: string, removedBy: string): Promise<void>;
+    /**
+     * Assign a role to a user (globally or scoped to a resource).
+     */
+    assignRole(userId: string, roleId: string, assignedBy: string, resourceType?: string, resourceId?: string): Promise<void>;
+    /**
+     * Remove a role from a user.
+     */
+    removeRole(userId: string, roleId: string, removedBy: string, resourceType?: string, resourceId?: string): Promise<void>;
+}
+/**
+ * Create a PermissionService instance from the LumenJS database.
+ */
+export declare function usePermissions(db: any, config?: Partial<ResolvedPermissionsConfig>): PermissionService;

package/dist/permissions/service.js

@@ -0,0 +1,210 @@
+const DEFAULT_OWNER_GRANTS = ['read', 'write', 'delete', 'share'];
+export class PermissionService {
+    constructor(db, config) {
+        this.db = db;
+        this.config = {
+            enabled: config?.enabled ?? true,
+            defaultOwnerGrants: config?.defaultOwnerGrants ?? DEFAULT_OWNER_GRANTS,
+        };
+    }
+    // ── Audit logging ──────────────────────────────────────────────
+    async audit(action, actorId, opts = {}) {
+        await this.db.run(`INSERT INTO _nk_permission_audit_log
+       (action, resource_type, resource_id, grantee_type, grantee_id, permission, role_id, actor_id, details)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, action, opts.resourceType ?? null, opts.resourceId ?? null, opts.granteeType ?? null, opts.granteeId ?? null, opts.permission ?? null, opts.roleId ?? null, actorId, opts.details ?? null);
+    }
+    /**
+     * Query audit log entries.
+     */
+    async getAuditLog(opts) {
+        let sql = 'SELECT * FROM _nk_permission_audit_log WHERE 1=1';
+        const params = [];
+        if (opts?.resourceType) {
+            sql += ' AND resource_type = ?';
+            params.push(opts.resourceType);
+        }
+        if (opts?.resourceId) {
+            sql += ' AND resource_id = ?';
+            params.push(opts.resourceId);
+        }
+        if (opts?.actorId) {
+            sql += ' AND actor_id = ?';
+            params.push(opts.actorId);
+        }
+        sql += ' ORDER BY created_at DESC LIMIT ?';
+        params.push(opts?.limit ?? 100);
+        return this.db.all(sql, ...params);
+    }
+    // ── Permission checks ─────────────────────────────────────────
+    /**
+     * Check if a user can perform an action on a resource.
+     *
+     * Check order:
+     * 1. Direct user grant
+     * 2. Public grant (anyone with the link)
+     * 3. Anonymous grant (only if anonymous flag set)
+     * 4. Role-based permissions (global roles, then resource-scoped roles)
+     * 5. Wildcard '*' permission matches any action
+     */
+    async canAccess(userId, permissionType, resourceType, resourceId, anonymous) {
+        if (!this.config.enabled)
+            return true;
+        const [, action] = permissionType.includes(':')
+            ? permissionType.split(':')
+            : [resourceType, permissionType];
+        // 1. Direct user grant
+        if (userId) {
+            const userGrant = await this.db.get(`SELECT 1 FROM _nk_resource_permissions
+         WHERE resource_type = ? AND resource_id = ?
+           AND grantee_type = 'user' AND grantee_id = ?
+           AND (permission = ? OR permission = '*')
+           AND (expires_at IS NULL OR expires_at > datetime('now'))`, resourceType, resourceId, userId, action);
+            if (userGrant)
+                return true;
+        }
+        // 2. Public grant
+        const publicGrant = await this.db.get(`SELECT 1 FROM _nk_resource_permissions
+       WHERE resource_type = ? AND resource_id = ?
+         AND grantee_type = 'public'
+         AND (permission = ? OR permission = '*')
+         AND (expires_at IS NULL OR expires_at > datetime('now'))`, resourceType, resourceId, action);
+        if (publicGrant)
+            return true;
+        // 3. Anonymous grant
+        if (anonymous) {
+            const anonGrant = await this.db.get(`SELECT 1 FROM _nk_resource_permissions
+         WHERE resource_type = ? AND resource_id = ?
+           AND grantee_type = 'anonymous'
+           AND (permission = ? OR permission = '*')
+           AND (expires_at IS NULL OR expires_at > datetime('now'))`, resourceType, resourceId, action);
+            if (anonGrant)
+                return true;
+        }
+        // 4. Role-based: check user's roles → role permissions
+        if (userId) {
+            const roleMatch = await this.db.get(`SELECT 1 FROM _nk_user_roles ur
+         JOIN _nk_roles r ON r.id = ur.role_id
+         WHERE ur.user_id = ?
+           AND (
+             (ur.resource_type IS NULL OR ur.resource_type = '')
+             OR (ur.resource_type = ? AND ur.resource_id = ?)
+           )
+           AND EXISTS (
+             SELECT 1 FROM json_each(r.permissions) je
+             WHERE je.value = ? OR je.value = ? || ':*' OR je.value = '*'
+           )`, userId, resourceType, resourceId, permissionType, resourceType);
+            if (roleMatch)
+                return true;
+        }
+        return false;
+    }
+    // ── Resource queries ──────────────────────────────────────────
+    /**
+     * Get all resource IDs of a given type that a user can access.
+     */
+    async getAccessibleResourceIds(userId, resourceType, permission) {
+        const [, action] = permission.includes(':')
+            ? permission.split(':')
+            : [resourceType, permission];
+        const rows = await this.db.all(`SELECT DISTINCT resource_id FROM _nk_resource_permissions
+       WHERE resource_type = ?
+         AND (
+           (grantee_type = 'user' AND grantee_id = ?)
+           OR grantee_type = 'public'
+         )
+         AND (permission = ? OR permission = '*')
+         AND (expires_at IS NULL OR expires_at > datetime('now'))`, resourceType, userId, action);
+        return rows.map((r) => r.resource_id);
+    }
+    /**
+     * Get all permissions for a resource.
+     */
+    async getPermissionsForResource(resourceType, resourceId) {
+        return this.db.all(`SELECT * FROM _nk_resource_permissions
+       WHERE resource_type = ? AND resource_id = ?
+         AND (expires_at IS NULL OR expires_at > datetime('now'))
+       ORDER BY created_at`, resourceType, resourceId);
+    }
+    // ── Mutations (all audited) ───────────────────────────────────
+    /**
+     * Initialize owner permissions when a resource is created.
+     */
+    async initOwnerPermissions(resourceType, resourceId, userId) {
+        for (const perm of this.config.defaultOwnerGrants) {
+            await this.db.run(`INSERT OR IGNORE INTO _nk_resource_permissions
+         (resource_type, resource_id, grantee_type, grantee_id, permission, granted_by)
+         VALUES (?, ?, 'user', ?, ?, ?)`, resourceType, resourceId, userId, perm, userId);
+        }
+        await this.audit('init_owner', userId, {
+            resourceType, resourceId,
+            details: `Granted: ${this.config.defaultOwnerGrants.join(', ')}`,
+        });
+    }
+    /**
+     * Grant a permission on a resource.
+     */
+    async grant(resourceType, resourceId, granteeType, granteeId, permission, grantedBy) {
+        await this.db.run(`INSERT OR IGNORE INTO _nk_resource_permissions
+       (resource_type, resource_id, grantee_type, grantee_id, permission, granted_by)
+       VALUES (?, ?, ?, ?, ?, ?)`, resourceType, resourceId, granteeType, granteeId, permission, grantedBy);
+        await this.audit('grant', grantedBy, {
+            resourceType, resourceId, granteeType, granteeId, permission,
+        });
+    }
+    /**
+     * Revoke a permission on a resource.
+     */
+    async revoke(resourceType, resourceId, granteeType, granteeId, permission, revokedBy) {
+        await this.db.run(`DELETE FROM _nk_resource_permissions
+       WHERE resource_type = ? AND resource_id = ?
+         AND grantee_type = ? AND COALESCE(grantee_id, '') = COALESCE(?, '')
+         AND permission = ?`, resourceType, resourceId, granteeType, granteeId, permission);
+        await this.audit('revoke', revokedBy, {
+            resourceType, resourceId, granteeType, granteeId, permission,
+        });
+    }
+    /**
+     * Make a resource publicly accessible (read).
+     */
+    async makePublic(resourceType, resourceId, grantedBy) {
+        await this.grant(resourceType, resourceId, 'public', null, 'read', grantedBy);
+    }
+    /**
+     * Remove public access from a resource.
+     */
+    async removePublic(resourceType, resourceId, removedBy) {
+        await this.db.run(`DELETE FROM _nk_resource_permissions
+       WHERE resource_type = ? AND resource_id = ? AND grantee_type = 'public'`, resourceType, resourceId);
+        await this.audit('remove_public', removedBy, { resourceType, resourceId });
+    }
+    /**
+     * Assign a role to a user (globally or scoped to a resource).
+     */
+    async assignRole(userId, roleId, assignedBy, resourceType, resourceId) {
+        await this.db.run(`INSERT OR IGNORE INTO _nk_user_roles (user_id, role_id, resource_type, resource_id)
+       VALUES (?, ?, ?, ?)`, userId, roleId, resourceType ?? null, resourceId ?? null);
+        await this.audit('assign_role', assignedBy, {
+            granteeType: 'user', granteeId: userId, roleId,
+            resourceType, resourceId,
+        });
+    }
+    /**
+     * Remove a role from a user.
+     */
+    async removeRole(userId, roleId, removedBy, resourceType, resourceId) {
+        await this.db.run(`DELETE FROM _nk_user_roles
+       WHERE user_id = ? AND role_id = ?
+         AND COALESCE(resource_type, '') = COALESCE(?, '')
+         AND COALESCE(resource_id, '') = COALESCE(?, '')`, userId, roleId, resourceType ?? null, resourceId ?? null);
+        await this.audit('remove_role', removedBy, {
+            granteeType: 'user', granteeId: userId, roleId,
+            resourceType, resourceId,
+        });
+    }
+}
+/**
+ * Create a PermissionService instance from the LumenJS database.
+ */
+export function usePermissions(db, config) {
+    return new PermissionService(db, config);
+}

package/dist/permissions/tables.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Auto-create permission tables in the LumenJS SQLite database.
+ * Follows the same pattern as ensureUsersTable() in auth/native-auth.ts.
+ */
+export declare function ensurePermissionTables(db: any): Promise<void>;