@zveltio/sdk 2.0.8 → 3.0.0-beta.1

package/dist/testing/with-test-db.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Postgres-backed integration test helper (S4-06 follow-up).
+ *
+ * `withTestDb(fn)` spins up a real Postgres container via `testcontainers`,
+ * yields a Kysely instance connected to it, runs the user's callback, then
+ * tears the container down. Use this when `mockDb` is insufficient — e.g.
+ * when an extension hook chains a real SELECT through `ctx.db`, or when you
+ * want to verify migrations apply cleanly.
+ *
+ * Requires:
+ *   - Docker / Podman running on the test host.
+ *   - `testcontainers` installed (peer dep — declare as devDep in the
+ *     extension's package.json). We import it dynamically so unit-test
+ *     workflows that never call `withTestDb` don't take the heavy hit.
+ *
+ * Cost model:
+ *   - First call: ~3-5s (image pull + container start). Subsequent calls
+ *     reuse the cached image, ~1-2s. Use one container across a `describe()`
+ *     block when you can — the wrapper supports nesting via `reuse`.
+ *
+ * Why a peer dep + dynamic import:
+ *   - `testcontainers` pulls `dockerode` + a bunch of Node-ish modules. We
+ *     don't want every consumer of `@zveltio/sdk/testing` to inherit that
+ *     weight just to use `mockDb`. By importing lazily, the cost is
+ *     opt-in at the call site.
+ */
+import type { Kysely } from 'kysely';
+export interface WithTestDbOptions {
+    /** Postgres image. Default: `postgres:18-alpine`. */
+    image?: string;
+    /** DB name to create. Default: `zveltio_test`. */
+    database?: string;
+    /** Optional SQL strings to run after the container is ready. */
+    migrations?: string[];
+    /**
+     * Container start timeout, ms. Default: 60_000. Cold pulls can be slow
+     * on the first run; CI environments may want 120_000.
+     */
+    startupTimeoutMs?: number;
+    /**
+     * If passed, the container is started once and reused. Pass `false`
+     * (default) to start + stop per call.
+     */
+    reuse?: boolean;
+}
+export interface TestDb {
+    /** Kysely instance — same shape as `ctx.db` in production. */
+    db: Kysely<any>;
+    /** Connection string the container exposed. */
+    connectionString: string;
+    /** Stop + remove the container (also closes the Kysely pool). */
+    cleanup(): Promise<void>;
+}
+/**
+ * Spin up Postgres, optionally run migrations, return a `TestDb` handle.
+ * The caller is responsible for calling `cleanup()` (typically inside an
+ * `afterAll`/`afterEach`).
+ *
+ * For the more common "scope the lifecycle to a test/describe block"
+ * pattern, prefer `withTestDb(fn)` below.
+ */
+export declare function startTestDb(opts?: WithTestDbOptions): Promise<TestDb>;
+/**
+ * Convenience wrapper: starts a TestDb, runs `fn`, always cleans up. The
+ * 95% case for integration tests. Returns whatever `fn` returns.
+ *
+ * @example
+ *   import { withTestDb } from '@zveltio/sdk/testing';
+ *   import myExtension from '../engine';
+ *
+ *   test('extension creates contact rows', async () => {
+ *     await withTestDb(async (db) => {
+ *       await db.schema.createTable('zvd_contacts').addColumn(...).execute();
+ *       const ctx = createTestContext({ db });
+ *       const app = await createTestApp(myExtension, { ctx });
+ *       const res = await app.request('/ext/my/contacts', { method: 'POST', ... });
+ *       expect(res.status).toBe(201);
+ *       const rows = await db.selectFrom('zvd_contacts').selectAll().execute();
+ *       expect(rows).toHaveLength(1);
+ *     });
+ *   });
+ */
+export declare function withTestDb<T>(fnOrOpts: ((db: Kysely<any>) => Promise<T>) | WithTestDbOptions, maybeFn?: (db: Kysely<any>) => Promise<T>): Promise<T>;
+/**
+ * Apply an ordered list of SQL strings against the db. Each entry runs in
+ * its own statement; semicolons in the source string split into multiple
+ * statements. Useful for replaying engine + extension migrations against
+ * the test db.
+ *
+ * @example
+ *   import { readFileSync } from 'fs';
+ *   import { sync as glob } from 'glob';
+ *   const files = glob('engine/migrations/*.sql').map((p) => readFileSync(p, 'utf8'));
+ *   await applyMigrationStrings(db, files);
+ */
+export declare function applyMigrationStrings(db: Kysely<any>, sqlStrings: string[]): Promise<void>;
+/**
+ * Same as `applyMigrationStrings` but takes file paths. Reads each file
+ * synchronously, applies in order. Bun-native — uses `Bun.file()`.
+ */
+export declare function applyMigrationFiles(db: Kysely<any>, paths: string[]): Promise<void>;
+/**
+ * Stop any reuse-cached container. Call this from a `globalTeardown` /
+ * `afterAll` so test runs don't leave dangling containers. No-op when no
+ * reuse container is active.
+ */
+export declare function stopReusedTestDb(): Promise<void>;
+/**
+ * Naive SQL statement splitter: splits on `;` outside of single-quoted
+ * strings and dollar-quoted blocks (`$$...$$`). Handles the migration-file
+ * styles Zveltio ships; not a full SQL parser.
+ *
+ * Public so tests can pin its behavior. Not part of the documented surface.
+ */
+export declare function splitStatements(src: string): string[];
+export declare const _internalForTests: {
+    splitStatements: typeof splitStatements;
+};
+//# sourceMappingURL=with-test-db.d.ts.map

package/dist/testing/with-test-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-test-db.d.ts","sourceRoot":"","sources":["../../src/testing/with-test-db.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,MAAM;IACrB,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAChB,+CAA+C;IAC/C,gBAAgB,EAAE,MAAM,CAAC;IACzB,iEAAiE;IACjE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AA6BD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4E/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAChC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,iBAAiB,EAC/D,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxC,OAAO,CAAC,CAAC,CAAC,CAYZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhG;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIzF;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBtD;AAgBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAuErD;AAGD,eAAO,MAAM,iBAAiB;;CAAsB,CAAC"}

package/dist/testing/with-test-db.js

@@ -0,0 +1,313 @@
+/**
+ * Postgres-backed integration test helper (S4-06 follow-up).
+ *
+ * `withTestDb(fn)` spins up a real Postgres container via `testcontainers`,
+ * yields a Kysely instance connected to it, runs the user's callback, then
+ * tears the container down. Use this when `mockDb` is insufficient — e.g.
+ * when an extension hook chains a real SELECT through `ctx.db`, or when you
+ * want to verify migrations apply cleanly.
+ *
+ * Requires:
+ *   - Docker / Podman running on the test host.
+ *   - `testcontainers` installed (peer dep — declare as devDep in the
+ *     extension's package.json). We import it dynamically so unit-test
+ *     workflows that never call `withTestDb` don't take the heavy hit.
+ *
+ * Cost model:
+ *   - First call: ~3-5s (image pull + container start). Subsequent calls
+ *     reuse the cached image, ~1-2s. Use one container across a `describe()`
+ *     block when you can — the wrapper supports nesting via `reuse`.
+ *
+ * Why a peer dep + dynamic import:
+ *   - `testcontainers` pulls `dockerode` + a bunch of Node-ish modules. We
+ *     don't want every consumer of `@zveltio/sdk/testing` to inherit that
+ *     weight just to use `mockDb`. By importing lazily, the cost is
+ *     opt-in at the call site.
+ */
+// ── Module-level reuse cache ────────────────────────────────────────────────
+//
+// When `reuse: true`, we keep a single container alive for the process
+// lifetime. The first call to `withTestDb` boots it; subsequent calls open
+// fresh DBs *inside* the same container (CREATE DATABASE per-call), so
+// tests stay isolated without paying the container-start cost again.
+let _sharedContainer = null;
+let _sharedClient = null;
+let _sharedDbCounter = 0;
+async function loadPgContainer() {
+    try {
+        return await import('@testcontainers/postgresql');
+    }
+    catch {
+        throw new Error(`withTestDb requires the '@testcontainers/postgresql' npm package. ` +
+            `Install it as a devDep in your extension:\n` +
+            `  bun add -d @testcontainers/postgresql pg @types/pg`);
+    }
+}
+async function loadKysely() {
+    return await import('kysely');
+}
+/**
+ * Spin up Postgres, optionally run migrations, return a `TestDb` handle.
+ * The caller is responsible for calling `cleanup()` (typically inside an
+ * `afterAll`/`afterEach`).
+ *
+ * For the more common "scope the lifecycle to a test/describe block"
+ * pattern, prefer `withTestDb(fn)` below.
+ */
+export async function startTestDb(opts = {}) {
+    const image = opts.image ?? 'postgres:18-alpine';
+    const database = opts.database ?? `zveltio_test_${Date.now()}_${Math.floor(Math.random() * 10_000)}`;
+    const startupTimeoutMs = opts.startupTimeoutMs ?? 60_000;
+    const tc = await loadPgContainer();
+    const { Kysely, PostgresDialect } = await loadKysely();
+    let host;
+    let port;
+    let username;
+    let password;
+    let createdContainer = null;
+    if (opts.reuse && _sharedContainer) {
+        host = _sharedContainer.getHost();
+        port = _sharedContainer.getMappedPort(5432);
+        username = _sharedContainer.getUsername();
+        password = _sharedContainer.getPassword();
+    }
+    else {
+        const builder = new tc.PostgreSqlContainer(image).withStartupTimeout(startupTimeoutMs);
+        createdContainer = await builder.start();
+        if (opts.reuse)
+            _sharedContainer = createdContainer;
+        host = createdContainer.getHost();
+        port = createdContainer.getMappedPort(5432);
+        username = createdContainer.getUsername();
+        password = createdContainer.getPassword();
+    }
+    // testcontainers' default db is `test`. Create our own so multiple
+    // reuse=true calls don't share state.
+    const adminConnStr = `postgres://${username}:${password}@${host}:${port}/postgres`;
+    const adminPool = await openPgPool(adminConnStr);
+    try {
+        await adminPool.query(`CREATE DATABASE "${database}"`);
+        _sharedDbCounter++;
+    }
+    finally {
+        await adminPool.end();
+    }
+    const connectionString = `postgres://${username}:${password}@${host}:${port}/${database}`;
+    const pool = await openPgPool(connectionString);
+    const db = new Kysely({
+        dialect: new PostgresDialect({ pool: pool }),
+    });
+    if (opts.migrations && opts.migrations.length > 0) {
+        await applyMigrationStrings(db, opts.migrations);
+    }
+    return {
+        db,
+        connectionString,
+        async cleanup() {
+            try {
+                await db.destroy();
+            }
+            catch {
+                /* */
+            }
+            try {
+                await pool.end();
+            }
+            catch {
+                /* */
+            }
+            if (createdContainer && !opts.reuse) {
+                try {
+                    await createdContainer.stop();
+                }
+                catch {
+                    /* */
+                }
+            }
+        },
+    };
+}
+/**
+ * Convenience wrapper: starts a TestDb, runs `fn`, always cleans up. The
+ * 95% case for integration tests. Returns whatever `fn` returns.
+ *
+ * @example
+ *   import { withTestDb } from '@zveltio/sdk/testing';
+ *   import myExtension from '../engine';
+ *
+ *   test('extension creates contact rows', async () => {
+ *     await withTestDb(async (db) => {
+ *       await db.schema.createTable('zvd_contacts').addColumn(...).execute();
+ *       const ctx = createTestContext({ db });
+ *       const app = await createTestApp(myExtension, { ctx });
+ *       const res = await app.request('/ext/my/contacts', { method: 'POST', ... });
+ *       expect(res.status).toBe(201);
+ *       const rows = await db.selectFrom('zvd_contacts').selectAll().execute();
+ *       expect(rows).toHaveLength(1);
+ *     });
+ *   });
+ */
+export async function withTestDb(fnOrOpts, maybeFn) {
+    const opts = typeof fnOrOpts === 'function' ? {} : fnOrOpts;
+    const fn = typeof fnOrOpts === 'function' ? fnOrOpts : maybeFn;
+    if (typeof fn !== 'function') {
+        throw new Error('withTestDb: callback is required');
+    }
+    const handle = await startTestDb(opts);
+    try {
+        return await fn(handle.db);
+    }
+    finally {
+        await handle.cleanup();
+    }
+}
+/**
+ * Apply an ordered list of SQL strings against the db. Each entry runs in
+ * its own statement; semicolons in the source string split into multiple
+ * statements. Useful for replaying engine + extension migrations against
+ * the test db.
+ *
+ * @example
+ *   import { readFileSync } from 'fs';
+ *   import { sync as glob } from 'glob';
+ *   const files = glob('engine/migrations/*.sql').map((p) => readFileSync(p, 'utf8'));
+ *   await applyMigrationStrings(db, files);
+ */
+export async function applyMigrationStrings(db, sqlStrings) {
+    const { sql } = await loadKysely();
+    for (const raw of sqlStrings) {
+        const statements = splitStatements(raw);
+        for (const stmt of statements) {
+            const trimmed = stmt.trim();
+            if (!trimmed)
+                continue;
+            await sql.raw(trimmed).execute(db);
+        }
+    }
+}
+/**
+ * Same as `applyMigrationStrings` but takes file paths. Reads each file
+ * synchronously, applies in order. Bun-native — uses `Bun.file()`.
+ */
+export async function applyMigrationFiles(db, paths) {
+    // Bun.file().text() returns a Promise<string>.
+    const contents = await Promise.all(paths.map((p) => Bun.file(p).text()));
+    return applyMigrationStrings(db, contents);
+}
+/**
+ * Stop any reuse-cached container. Call this from a `globalTeardown` /
+ * `afterAll` so test runs don't leave dangling containers. No-op when no
+ * reuse container is active.
+ */
+export async function stopReusedTestDb() {
+    if (_sharedClient) {
+        try {
+            await _sharedClient.end();
+        }
+        catch {
+            /* */
+        }
+        _sharedClient = null;
+    }
+    if (_sharedContainer) {
+        try {
+            await _sharedContainer.stop();
+        }
+        catch {
+            /* */
+        }
+        _sharedContainer = null;
+    }
+}
+// ── Internals ───────────────────────────────────────────────────────────────
+/** Open a pg connection pool. Uses `pg` (peer dep with testcontainers). */
+async function openPgPool(connectionString) {
+    const pg = await import('pg').catch(() => {
+        throw new Error(`withTestDb requires the 'pg' npm package. Install it alongside testcontainers:\n` +
+            `  bun add -d testcontainers pg @types/pg`);
+    });
+    // pg's Pool — the Kysely PostgresDialect accepts this directly.
+    return new pg.Pool({ connectionString });
+}
+/**
+ * Naive SQL statement splitter: splits on `;` outside of single-quoted
+ * strings and dollar-quoted blocks (`$$...$$`). Handles the migration-file
+ * styles Zveltio ships; not a full SQL parser.
+ *
+ * Public so tests can pin its behavior. Not part of the documented surface.
+ */
+export function splitStatements(src) {
+    const out = [];
+    let buf = '';
+    let i = 0;
+    while (i < src.length) {
+        const ch = src[i];
+        // Comments: -- to end of line
+        if (ch === '-' && src[i + 1] === '-') {
+            while (i < src.length && src[i] !== '\n') {
+                buf += src[i++];
+            }
+            continue;
+        }
+        // Block comments: /* ... */
+        if (ch === '/' && src[i + 1] === '*') {
+            buf += src[i++];
+            buf += src[i++];
+            while (i < src.length && !(src[i] === '*' && src[i + 1] === '/')) {
+                buf += src[i++];
+            }
+            if (i < src.length) {
+                buf += src[i++];
+                buf += src[i++];
+            }
+            continue;
+        }
+        // Single-quoted strings: handle escaped quotes.
+        if (ch === "'") {
+            buf += src[i++];
+            while (i < src.length) {
+                if (src[i] === "'" && src[i + 1] === "'") {
+                    buf += src[i++];
+                    buf += src[i++];
+                    continue;
+                }
+                if (src[i] === "'") {
+                    buf += src[i++];
+                    break;
+                }
+                buf += src[i++];
+            }
+            continue;
+        }
+        // Dollar-quoted blocks: $$ ... $$ or $tag$ ... $tag$.
+        if (ch === '$') {
+            const tagMatch = src.slice(i).match(/^\$[a-zA-Z0-9_]*\$/);
+            if (tagMatch) {
+                const tag = tagMatch[0];
+                buf += tag;
+                i += tag.length;
+                const endIdx = src.indexOf(tag, i);
+                if (endIdx < 0) {
+                    buf += src.slice(i);
+                    i = src.length;
+                    break;
+                }
+                buf += src.slice(i, endIdx + tag.length);
+                i = endIdx + tag.length;
+                continue;
+            }
+        }
+        if (ch === ';') {
+            out.push(buf);
+            buf = '';
+            i++;
+            continue;
+        }
+        buf += src[i++];
+    }
+    if (buf.trim())
+        out.push(buf);
+    return out;
+}
+// ── Internal helpers for tests only ────────────────────────────────────────
+export const _internalForTests = { splitStatements };

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAUrC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAYrC"}

package/dist/utils.js

@@ -14,6 +14,8 @@ export function generateUUID() {
     const bytes = crypto.getRandomValues(new Uint8Array(16));
     bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
     bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant bits
-    const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
+    const hex = Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }

package/dist/validate/index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Pre-publish validators for Zveltio extensions (S4-04).
+ *
+ * Pure functions — no Node-specific imports, no Zod runtime. Designed so the
+ * CLI (`zveltio extension validate`) can call them on file contents read from
+ * disk, the engine can call them on uploaded archives, and registry code can
+ * call them on publish. Each returns a `ValidationResult` with structured
+ * diagnostics instead of throwing, so the CLI can print all problems at once.
+ *
+ * What's checked:
+ *   - manifest.json shape (required fields, semver, sane category)
+ *   - name matches the folder path it lives in
+ *   - peerDependencies appear on the platform allow-list
+ *   - migration SQL files parse + table coverage looks sane
+ *   - destructive DDL in migrations has a `-- DOWN` section
+ *   - bundle size stays within quota
+ *
+ * Out of scope (deferred):
+ *   - Loading the extension module to inspect its default export. Requires
+ *     a Bun runtime + sandbox. CLI's `validate` cannot guarantee correctness
+ *     for runtime contracts; that's what `extension types` (S4-01) + `tsc`
+ *     gives you locally.
+ *   - Building the Studio bundle. Too slow; pair with `zveltio extension build`
+ *     which can call validate as a sub-step.
+ */
+export interface ValidationError {
+    /** Stable machine-readable code (e.g. `MANIFEST_NAME_MISMATCH`). */
+    code: string;
+    /** Operator-facing message. */
+    message: string;
+    /** Optional file path the error applies to, relative to the extension root. */
+    file?: string;
+}
+export interface ValidationResult {
+    ok: boolean;
+    errors: ValidationError[];
+    /** Counts surfaced for human-readable summaries. */
+    stats: {
+        tables: number;
+        migrations: number;
+        peerDeps: number;
+    };
+}
+export interface ManifestValidationInput {
+    /** Parsed JSON object (or `null` if file couldn't be read). */
+    manifest: unknown;
+    /** Folder path slug — e.g. `'finance/invoicing'`. Used for name-match. */
+    expectedName?: string;
+}
+export declare function validateManifest(input: ManifestValidationInput): ValidationError[];
+export interface PeerDepsValidationInput {
+    /** From manifest.json: `{ "lodash": "^4.0.0", ... }` (or undefined). */
+    peerDependencies: Record<string, string> | undefined;
+    /** The platform allow-list (caller supplies it — see peer-deps-allowlist.ts). */
+    allowedPackages: ReadonlySet<string>;
+}
+export declare function validatePeerDependencies(input: PeerDepsValidationInput): ValidationError[];
+export interface MigrationsValidationInput {
+    /** Pairs of (filename, sql contents). Filename is just for diagnostics. */
+    files: Array<{
+        filename: string;
+        sql: string;
+    }>;
+    /** When `true`, every migration with destructive DDL must have a -- DOWN section. */
+    requireDownForDestructive?: boolean;
+}
+export declare function validateMigrations(input: MigrationsValidationInput): ValidationError[];
+export interface FilePresenceInput {
+    /** Mapping of relative path → existence boolean. Caller does the disk hit. */
+    paths: Record<string, boolean>;
+    /** Paths that MUST exist. */
+    required: string[];
+}
+export declare function validateFilePresence(input: FilePresenceInput): ValidationError[];
+export interface BundleSizeInput {
+    /** Size of the extension folder (excluding node_modules), in bytes. */
+    bundleBytes: number;
+    /** Override the default cap (50 MB). */
+    bundleSizeKbMax?: number;
+}
+export declare function validateBundleSize(input: BundleSizeInput): ValidationError[];
+export interface ValidateExtensionInput {
+    manifest: ManifestValidationInput;
+    peerDeps: PeerDepsValidationInput;
+    migrations: MigrationsValidationInput;
+    filePresence: FilePresenceInput;
+    bundleSize?: BundleSizeInput;
+    /** Numbers used to fill the result's `stats` for human summaries. */
+    stats: {
+        tables: number;
+        migrations: number;
+    };
+}
+export declare function validateExtension(input: ValidateExtensionInput): ValidationResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/validate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,oDAAoD;IACpD,KAAK,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AA+CD,MAAM,WAAW,uBAAuB;IACtC,+DAA+D;IAC/D,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,uBAAuB,GAAG,eAAe,EAAE,CA2DlF;AAID,MAAM,WAAW,uBAAuB;IACtC,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACrD,iFAAiF;IACjF,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,uBAAuB,GAAG,eAAe,EAAE,CAyC1F;AAID,MAAM,WAAW,yBAAyB;IACxC,2EAA2E;IAC3E,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChD,qFAAqF;IACrF,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAkBD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,yBAAyB,GAAG,eAAe,EAAE,CAqCtF;AAID,MAAM,WAAW,iBAAiB;IAChC,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,eAAe,EAAE,CAQhF;AAID,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAID,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,EAAE,CAY5E;AAID,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,UAAU,EAAE,yBAAyB,CAAC;IACtC,YAAY,EAAE,iBAAiB,CAAC;IAChC,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,qEAAqE;IACrE,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/C;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,gBAAgB,CAiBjF"}