@pikku/cli 0.12.24 → 0.12.25

package/dist/src/functions/db/sqlite-runtime-node.js

@@ -0,0 +1,51 @@
+class NodeSqliteStatement {
+    stmt;
+    reader;
+    constructor(stmt) {
+        this.stmt = stmt;
+        this.reader = Boolean(stmt.reader);
+    }
+    all(...parameters) {
+        return this.stmt.all(...parameters);
+    }
+    get(...parameters) {
+        return this.stmt.get(...parameters) ?? null;
+    }
+    iterate(...parameters) {
+        return this.stmt.iterate(...parameters);
+    }
+    run(...parameters) {
+        const result = this.stmt.run(...parameters);
+        return {
+            changes: result.changes,
+            lastInsertRowid: result.lastInsertRowid,
+        };
+    }
+}
+class NodeSqliteDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    prepare(sql) {
+        return new NodeSqliteStatement(this.db.prepare(sql));
+    }
+    close() {
+        this.db.close();
+    }
+}
+async function importNodeSqlite() {
+    const dynamicImport = new Function('return import("node:sqlite")');
+    return dynamicImport();
+}
+export async function createNodeSqliteRuntime() {
+    const { DatabaseSync } = await importNodeSqlite();
+    return {
+        open(filename) {
+            return new NodeSqliteDatabase(new DatabaseSync(filename));
+        },
+    };
+}

package/dist/src/functions/db/sqlite-runtime.d.ts

@@ -0,0 +1,20 @@
+export interface SyncSqliteChanges {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+export interface SyncSqliteStatement {
+    reader: boolean;
+    all(...parameters: unknown[]): unknown[];
+    get(...parameters: unknown[]): unknown | null;
+    iterate(...parameters: unknown[]): IterableIterator<unknown>;
+    run(...parameters: unknown[]): SyncSqliteChanges;
+}
+export interface SyncSqliteDatabase {
+    exec(sql: string): void;
+    prepare(sql: string): SyncSqliteStatement;
+    close(): void;
+}
+export interface SqliteRuntime {
+    open(filename: string): SyncSqliteDatabase;
+}
+export declare function loadSqliteRuntime(): Promise<SqliteRuntime>;

package/dist/src/functions/db/sqlite-runtime.js

@@ -0,0 +1,13 @@
+let runtimePromise;
+export async function loadSqliteRuntime() {
+    runtimePromise ??= (async () => {
+        const isBunRuntime = typeof globalThis.Bun !== 'undefined';
+        if (isBunRuntime) {
+            const { bunSqliteRuntime } = await import('./sqlite-runtime-bun.js');
+            return bunSqliteRuntime;
+        }
+        const { createNodeSqliteRuntime } = await import('./sqlite-runtime-node.js');
+        return createNodeSqliteRuntime();
+    })();
+    return runtimePromise;
+}

package/dist/src/functions/validate/workspace-validate.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const FindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+    }>;
+    message: z.ZodString;
+    path: z.ZodString;
+    fixHint: z.ZodString;
+}, z.core.$strip>;
+export type Finding = z.infer<typeof FindingSchema>;
+export declare const WorkspaceValidateInput: z.ZodObject<{}, z.core.$strip>;
+export declare const WorkspaceValidateOutput: z.ZodObject<{
+    ok: z.ZodBoolean;
+    root: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            warn: "warn";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        path: z.ZodString;
+        fixHint: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function findProjectRoot(startDir: string): Promise<string>;
+export declare function readJsonSafe<T>(path: string): Promise<T | null>;
+export declare function readTextSafe(path: string): Promise<string | null>;
+export declare function runWorkspaceValidate(startDir?: string): Promise<z.infer<typeof WorkspaceValidateOutput>>;
+export declare const renderWorkspaceValidate: (_s: unknown, { ok, root, findings }: z.infer<typeof WorkspaceValidateOutput>) => void;

package/dist/src/functions/validate/workspace-validate.js

@@ -0,0 +1,258 @@
+import { existsSync } from 'node:fs';
+import { readFile, readdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { added, changed, dim, removed } from '../../fabric/lib/output.js';
+export const FindingSchema = z.object({
+    id: z.string(),
+    severity: z.enum(['error', 'warn', 'info']),
+    message: z.string(),
+    path: z.string(),
+    fixHint: z.string(),
+});
+export const WorkspaceValidateInput = z.object({});
+export const WorkspaceValidateOutput = z.object({
+    ok: z.boolean(),
+    root: z.string(),
+    findings: z.array(FindingSchema),
+});
+export async function findProjectRoot(startDir) {
+    let dir = startDir;
+    while (true) {
+        if (existsSync(join(dir, 'package.json'))) {
+            try {
+                const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf8'));
+                if (pkg.workspaces)
+                    return dir;
+            }
+            catch {
+                // ignore parse errors
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return startDir;
+        dir = parent;
+    }
+}
+export async function readJsonSafe(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid JSON in ${path}: ${message}`);
+    }
+}
+export async function readTextSafe(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function hasAuthSessionMiddleware(fnDir) {
+    const metaPath = join(fnDir, '.pikku', 'middleware', 'pikku-middleware-groups-meta.gen.json');
+    const meta = await readJsonSafe(metaPath);
+    if (!meta?.instances)
+        return false;
+    return Object.values(meta.instances).some((instance) => instance.definitionId === 'authJsSession');
+}
+function migrationCreatesTable(sql, tableName) {
+    const escapedTable = tableName.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+    const re = new RegExp(`\\bcreate\\s+table\\s+(?:if\\s+not\\s+exists\\s+)?["'\`]?${escapedTable}["'\`]?\\b`, 'i');
+    return re.test(sql);
+}
+export async function runWorkspaceValidate(startDir = process.cwd()) {
+    const root = await findProjectRoot(startDir);
+    const findings = [];
+    const e = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'error', message, path, fixHint });
+    };
+    const w = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'warn', message, path, fixHint });
+    };
+    const info = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'info', message, path, fixHint });
+    };
+    const pikkuConfigPath = join(root, 'pikku.config.json');
+    const pikkuConfig = await readJsonSafe(pikkuConfigPath);
+    if (!pikkuConfig) {
+        e('pikku-config-missing', 'pikku.config.json not found at project root', pikkuConfigPath, 'Create pikku.config.json with srcDirectories pointing to packages/functions/src, outDir, and clientFiles');
+    }
+    else {
+        if (!pikkuConfig.srcDirectories) {
+            e('pikku-config-no-src-dirs', 'pikku.config.json missing "srcDirectories"', pikkuConfigPath, 'Add "srcDirectories": ["packages/functions/src"] to pikku.config.json');
+        }
+        if (!pikkuConfig.outDir) {
+            e('pikku-config-no-out-dir', 'pikku.config.json missing "outDir"', pikkuConfigPath, 'Add "outDir": "packages/functions/.pikku" to pikku.config.json');
+        }
+        if (!pikkuConfig.clientFiles) {
+            info('pikku-config-no-client-files', 'pikku.config.json missing "clientFiles" — no generated SDK or React Query hooks', pikkuConfigPath, 'Add clientFiles.rpcMapDeclarationFile and clientFiles.reactQueryFile pointing to packages/functions-sdk/src/pikku/');
+        }
+    }
+    const hasConfiguredDevDb = Boolean(pikkuConfig?.dev?.db);
+    const rootPkgPath = join(root, 'package.json');
+    const rootPkg = await readJsonSafe(rootPkgPath);
+    if (!rootPkg) {
+        e('root-package-missing', 'root package.json not found', rootPkgPath, 'Create a root package.json with workspaces: {"workspaces": ["packages/*", "apps/*"]}');
+    }
+    else {
+        if (!rootPkg.workspaces) {
+            w('root-package-no-workspaces', 'root package.json missing "workspaces"', rootPkgPath, 'Add "workspaces": ["packages/*", "apps/*"] to enable yarn workspaces');
+        }
+        const allDeps = {
+            ...rootPkg.dependencies,
+            ...rootPkg.devDependencies,
+        };
+        if (!allDeps['@pikku/core']) {
+            e('missing-core', '@pikku/core not in dependencies', rootPkgPath, 'Add "@pikku/core" to dependencies');
+        }
+        for (const [pkg, spec] of Object.entries(allDeps)) {
+            if (typeof spec !== 'string' || !spec.startsWith('file:'))
+                continue;
+            const relPath = spec.slice(5);
+            if (!relPath.includes('vendor'))
+                continue;
+            const absPath = join(root, relPath);
+            if (!existsSync(absPath)) {
+                w(`vendor-missing-${pkg.replace(/[@/]/g, '-')}`, `Vendor file missing for ${pkg}: ${relPath}`, absPath, `Restore or replace the missing vendor package at ${relPath}`);
+            }
+        }
+    }
+    const fnDir = join(root, 'packages', 'functions');
+    if (!existsSync(fnDir)) {
+        e('functions-pkg-missing', 'packages/functions/ directory not found', fnDir, 'Create packages/functions/ as a workspace containing src/, config.ts, and any local db assets you use');
+    }
+    else {
+        const fnPkgPath = join(fnDir, 'package.json');
+        const fnPkg = await readJsonSafe(fnPkgPath);
+        if (!fnPkg) {
+            e('functions-package-json-missing', 'packages/functions/package.json not found', fnPkgPath, 'Create packages/functions/package.json and declare the workspace package');
+        }
+        else if (fnPkg.type !== 'module') {
+            w('functions-pkg-no-esm', 'packages/functions/package.json is missing "type": "module"', fnPkgPath, 'Add "type": "module" to packages/functions/package.json');
+        }
+        const servicesPath = join(fnDir, 'src', 'services.ts');
+        const servicesText = await readTextSafe(servicesPath);
+        if (!servicesText) {
+            w('services-missing', 'packages/functions/src/services.ts not found', servicesPath, 'Create services.ts and export your service factory for the workspace');
+        }
+        const migrationsDir = join(fnDir, 'db', 'migrations');
+        const authEnabled = await hasAuthSessionMiddleware(fnDir);
+        let createsAppUser = false;
+        let createsAuthVerificationToken = false;
+        if (existsSync(migrationsDir)) {
+            try {
+                const files = (await readdir(migrationsDir))
+                    .filter((f) => f.endsWith('.sql'))
+                    .sort();
+                const nums = [];
+                for (const f of files) {
+                    const m = f.match(/^(\d+)/);
+                    if (m)
+                        nums.push(parseInt(m[1], 10));
+                }
+                for (let idx = 1; idx < nums.length; idx++) {
+                    if (nums[idx] !== nums[idx - 1] + 1) {
+                        const missing = `${nums[idx - 1] + 1}..${nums[idx] - 1}`;
+                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive. Add the missing .sql file or renumber if not yet applied.');
+                        break;
+                    }
+                }
+                for (const f of files) {
+                    const sql = await readTextSafe(join(migrationsDir, f));
+                    if (!sql)
+                        continue;
+                    createsAppUser ||= migrationCreatesTable(sql, 'app_user');
+                    createsAuthVerificationToken ||= migrationCreatesTable(sql, 'auth_verification_token');
+                }
+            }
+            catch {
+                // readdir failure — skip
+            }
+        }
+        if (authEnabled && !hasConfiguredDevDb) {
+            e('auth-dev-db-missing', 'Auth middleware is registered, but pikku.config.json is missing dev.db so local auth schema validation and db migrate cannot run', pikkuConfigPath, 'Add dev.db to pikku.config.json so `pikku db migrate` can create and validate the local auth schema');
+        }
+        if (authEnabled && !createsAppUser) {
+            e('auth-schema-missing-app-user', 'Auth middleware is registered, but no SQL migration creates the app_user table', migrationsDir, 'Add a migration that creates app_user before enabling auth');
+        }
+        if (authEnabled && !createsAuthVerificationToken) {
+            e('auth-schema-missing-verification-token', 'Auth middleware is registered, but no SQL migration creates the auth_verification_token table', migrationsDir, 'Add a migration that creates auth_verification_token before enabling auth');
+        }
+        const dbTypesPath = join(fnDir, 'src', 'types', 'db.types.ts');
+        const dbTypesText = await readTextSafe(dbTypesPath);
+        if (dbTypesText) {
+            const isReexport = dbTypesText.includes('.pikku/db/schema') ||
+                dbTypesText.includes('.pikku\\db\\schema');
+            const hasInlineTypes = /(?:^|\n)\s*(?:export\s+)?(?:interface\s+\w|type\s+\w+\s*=)/.test(dbTypesText);
+            if (hasInlineTypes && !isReexport) {
+                w('db-types-hand-edited', 'src/types/db.types.ts contains inline type definitions — it should only re-export from .pikku', dbTypesPath, "Replace the file with a single line: export type { DB } from '../../.pikku/db/schema.js' then regenerate");
+            }
+        }
+        if (!existsSync(join(fnDir, 'src', 'functions'))) {
+            info('functions-dir-missing', 'packages/functions/src/functions/ not found', join(fnDir, 'src', 'functions'), 'Create src/functions/ to hold pikkuSessionlessFunc definitions');
+        }
+        if (!existsSync(join(fnDir, 'src', 'wirings'))) {
+            info('wirings-dir-missing', 'packages/functions/src/wirings/ not found', join(fnDir, 'src', 'wirings'), 'Create src/wirings/ for transport bindings such as *.http.ts or *.queue.ts');
+        }
+        if (!existsSync(join(fnDir, 'src', 'config.ts'))) {
+            info('config-missing', 'packages/functions/src/config.ts not found', join(fnDir, 'src', 'config.ts'), 'Create src/config.ts and export your workspace config factory');
+        }
+    }
+    const testsDir = join(fnDir, 'tests');
+    if (!existsSync(testsDir)) {
+        info('tests-missing', 'packages/functions/tests/ not found — no function test harness', testsDir, 'Run `pikku tests init` to scaffold the function test harness');
+    }
+    const sdkDir = join(root, 'packages', 'functions-sdk');
+    if (!existsSync(sdkDir)) {
+        info('functions-sdk-missing', 'packages/functions-sdk/ not found — generated RPC client and React Query hooks will not be available', sdkDir, 'Create packages/functions-sdk/ as a workspace with src/pikku/ and point clientFiles there');
+    }
+    const ok = !findings.some((f) => f.severity === 'error');
+    return { ok, root, findings };
+}
+export const renderWorkspaceValidate = (_s, { ok, root, findings }) => {
+    if (findings.length === 0) {
+        console.log(added('✓  All checks passed — workspace is Pikku-compatible'));
+        return;
+    }
+    const relPath = (p) => p.startsWith(root + '/') || p.startsWith(root + '\\')
+        ? p.slice(root.length + 1)
+        : p;
+    const errors = findings.filter((f) => f.severity === 'error');
+    const warns = findings.filter((f) => f.severity === 'warn');
+    const infos = findings.filter((f) => f.severity === 'info');
+    for (const f of [...errors, ...warns, ...infos]) {
+        const icon = f.severity === 'error'
+            ? removed('✗')
+            : f.severity === 'warn'
+                ? changed('⚠')
+                : dim('ℹ');
+        console.log(`${icon}  ${f.message}`);
+        console.log(`   ${dim('path:')}   ${relPath(f.path)}`);
+        console.log(`   ${dim('fix:')}    ${f.fixHint}`);
+        console.log();
+    }
+    const counts = [];
+    if (errors.length) {
+        counts.push(removed(`${errors.length} error${errors.length !== 1 ? 's' : ''}`));
+    }
+    if (warns.length) {
+        counts.push(changed(`${warns.length} warning${warns.length !== 1 ? 's' : ''}`));
+    }
+    if (infos.length) {
+        counts.push(dim(`${infos.length} info${infos.length !== 1 ? 's' : ''}`));
+    }
+    console.log('─'.repeat(40));
+    console.log(counts.join('  '));
+    if (ok) {
+        console.log();
+        console.log(added('✓') + '  ' + dim('no errors — workspace is structurally sound'));
+    }
+};

package/dist/src/functions/wirings/cli/pikku-command-cli-types.js

@@ -12,7 +12,7 @@ export const pikkuCLITypes = pikkuSessionlessFunc({
         // services types) — skip schema generation. Full mode would dynamic-import
         // pikku-types.gen.ts, which re-exports the not-yet-written cli-types file.
         const visitState = bootstrap
-            ? await getInspectorState(false, true, false)
+            ? await getInspectorState(false, true, true)
             : await getInspectorState();
         const functionTypesImportPath = getFileImportRelativePath(cliTypesFile, functionTypesFile, packageMappings);
         // Check for required types

package/dist/src/functions/wirings/emails/pikku-command-emails.d.ts

@@ -0,0 +1,6 @@
+import type { PikkuCLIConfig } from '../../../../types/config.js';
+import type { CLILogger } from '../../../services/cli-logger.service.js';
+export declare const pikkuEmails: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export declare function generateEmailsArtifacts(logger: CLILogger, config: Pick<PikkuCLIConfig, 'outDir'> & {
+    emailTemplatesDir?: string;
+}): Promise<true | undefined>;

package/dist/src/functions/wirings/emails/pikku-command-emails.js

@@ -0,0 +1,172 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeEmailsModule } from './serialize-emails.js';
+function sha256(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+function extractVariables(...sources) {
+    const variables = new Set();
+    for (const source of sources) {
+        for (const match of source.matchAll(/\{\{\s*([^}]+?)\s*\}\}/g)) {
+            const key = String(match[1]).trim();
+            if (!key || key === 'content' || key.startsWith('>'))
+                continue;
+            const rootKey = key.split('.')[0];
+            if (rootKey === 't' || rootKey === 'theme' || rootKey === 'locale')
+                continue;
+            if (rootKey === 'subject')
+                continue;
+            variables.add(rootKey);
+        }
+    }
+    return [...variables].sort();
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+        return `{${entries
+            .map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function collectStringLeaves(value) {
+    if (typeof value === 'string') {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectStringLeaves(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.values(value).flatMap((nested) => collectStringLeaves(nested));
+    }
+    return [];
+}
+export const pikkuEmails = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        return generateEmailsArtifacts(logger, config);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating emails',
+            commandEnd: 'Generated emails',
+        }),
+    ],
+});
+export async function generateEmailsArtifacts(logger, config) {
+    const emailDir = config.emailTemplatesDir;
+    if (!emailDir) {
+        logger.debug({
+            message: 'Skipping emails (set emailTemplatesDir in pikku.config.json to enable).',
+            type: 'skip',
+        });
+        return;
+    }
+    const typedOut = join(config.outDir, 'email', 'pikku-emails.gen.ts');
+    const metaOut = join(config.outDir, 'email', 'pikku-emails-meta.gen.json');
+    const [themeRaw, localeFiles, templateFiles, partialFiles] = await Promise.all([
+        readFile(join(emailDir, 'theme.json'), 'utf8').catch(() => '{}'),
+        readdir(join(emailDir, 'locales')).catch(() => []),
+        readdir(join(emailDir, 'templates')).catch(() => []),
+        readdir(join(emailDir, 'partials')).catch(() => []),
+    ]);
+    const theme = JSON.parse(themeRaw);
+    const locales = Object.fromEntries(await Promise.all(localeFiles
+        .filter((file) => extname(file) === '.json')
+        .map(async (file) => {
+        const locale = basename(file, '.json');
+        const raw = await readFile(join(emailDir, 'locales', file), 'utf8');
+        return [locale, JSON.parse(raw)];
+    })));
+    const partials = Object.fromEntries(await Promise.all(partialFiles
+        .filter((file) => extname(file) === '.html')
+        .map(async (file) => {
+        const name = basename(file, '.html');
+        const raw = await readFile(join(emailDir, 'partials', file), 'utf8');
+        return [name, raw];
+    })));
+    const templateNames = [
+        ...new Set(templateFiles
+            .filter((file) => file.endsWith('.html') ||
+            file.endsWith('.subject.txt') ||
+            file.endsWith('.text.txt'))
+            .map((file) => file.endsWith('.subject.txt')
+            ? file.slice(0, -'.subject.txt'.length)
+            : file.endsWith('.text.txt')
+                ? file.slice(0, -'.text.txt'.length)
+                : file.slice(0, -'.html'.length))),
+    ].sort();
+    if (templateNames.length === 0) {
+        logger.debug({
+            message: 'Skipping emails (no templates found).',
+            type: 'skip',
+        });
+        return;
+    }
+    const templates = Object.fromEntries(await Promise.all(templateNames.map(async (templateName) => {
+        const [html, subject, text] = await Promise.all([
+            readFile(join(emailDir, 'templates', `${templateName}.html`), 'utf8'),
+            readFile(join(emailDir, 'templates', `${templateName}.subject.txt`), 'utf8'),
+            readFile(join(emailDir, 'templates', `${templateName}.text.txt`), 'utf8').catch(() => ''),
+        ]);
+        const localeSources = Object.values(locales).flatMap((strings) => collectStringLeaves(strings));
+        const variables = extractVariables(html, subject, text, ...Object.values(partials), ...localeSources);
+        const hashes = Object.fromEntries(Object.entries(locales).map(([locale, strings]) => {
+            const localePayload = stableStringify({
+                templateName,
+                locale,
+                theme,
+                strings,
+                partials,
+                subject,
+                html,
+                text,
+            });
+            return [
+                locale,
+                {
+                    contentHash: sha256(localePayload),
+                    htmlHash: sha256(stableStringify({ html, partials, theme, strings })),
+                    subjectHash: sha256(stableStringify({ subject, strings })),
+                    textHash: sha256(stableStringify({ text, strings })),
+                },
+            ];
+        }));
+        return [
+            templateName,
+            {
+                html,
+                subject,
+                text,
+                variables,
+                hashes,
+            },
+        ];
+    })));
+    const meta = {
+        src: emailDir,
+        themeHash: sha256(stableStringify(theme)),
+        templates: Object.fromEntries(Object.entries(templates).map(([name, template]) => [
+            name,
+            {
+                variables: template.variables,
+                hasHtml: Boolean(template.html),
+                hasSubject: Boolean(template.subject),
+                hasText: Boolean(template.text),
+                locales: template.hashes,
+            },
+        ])),
+    };
+    await writeFileInDir(logger, typedOut, serializeEmailsModule({ theme, locales, partials, templates }));
+    await writeFileInDir(logger, metaOut, JSON.stringify(meta, null, 2), {
+        ignoreModifyComment: true,
+    });
+    return true;
+}

package/dist/src/functions/wirings/emails/serialize-emails.d.ts

@@ -0,0 +1,20 @@
+type EmailTemplateAssets = {
+    html: string;
+    subject: string;
+    text: string;
+    variables: string[];
+    hashes: Record<string, {
+        contentHash: string;
+        htmlHash: string;
+        subjectHash: string;
+        textHash: string;
+    }>;
+};
+type SerializeEmailsInput = {
+    theme: Record<string, unknown>;
+    locales: Record<string, Record<string, unknown>>;
+    partials: Record<string, string>;
+    templates: Record<string, EmailTemplateAssets>;
+};
+export declare const serializeEmailsModule: ({ theme, locales, partials, templates, }: SerializeEmailsInput) => string;
+export {};