@adula/kit 0.2.0-alpha.1

package/build/commands/resource.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, args, flags } from '@adonisjs/core/ace';
+import { generateResource } from '../src/commands/generator.js';
+import { fileURLToPath } from 'node:url';
+export default class Resource extends BaseCommand {
+    static commandName = 'adula:resource';
+    static description = 'Generate a scoped resource, migration, model, validator, factory and security contract';
+    async run() {
+        if (!this.module) {
+            this.logger.error('--module is required');
+            this.exitCode = 1;
+            return;
+        }
+        const files = await generateResource(fileURLToPath(this.app.appRoot), this.name, this.module);
+        files.forEach((file) => this.logger.success(file));
+        this.logger.info('Set bilingual labels, fill the resource definition, migrate, and run the generated security contract.');
+    }
+}
+__decorate([
+    args.string()
+], Resource.prototype, "name", void 0);
+__decorate([
+    flags.string()
+], Resource.prototype, "module", void 0);

package/build/commands/storage_migrate.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class StorageMigrate extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    static options: {
+        startApp: boolean;
+    };
+    from: string;
+    to: string;
+    dryRun: boolean;
+    run(): Promise<void>;
+}

package/build/commands/storage_migrate.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, args, flags } from '@adonisjs/core/ace';
+import { migrateStorage } from '../src/attachments/storage_migrate.js';
+export default class StorageMigrate extends BaseCommand {
+    static commandName = 'adula:storage:migrate';
+    static description = 'Copy attachment files from one Drive disk to another and repoint their rows';
+    static options = { startApp: true };
+    async run() {
+        const { default: db } = await import('@adonisjs/lucid/services/db');
+        const { default: drive } = await import('@adonisjs/drive/services/main');
+        const { configProvider } = await import('@adonisjs/core');
+        const resolved = await configProvider.resolve(this.app, this.app.config.get('drive'));
+        const result = await migrateStorage(db.connection().getWriteClient(), {
+            from: this.from,
+            to: this.to,
+            disks: Object.keys(resolved?.config.services ?? {}),
+            dryRun: Boolean(this.dryRun),
+            use: (name) => drive.use(name),
+            report: (line) => this.logger.info(line),
+        });
+        this.logger.log(JSON.stringify(result));
+        if (result.failed.length)
+            this.exitCode = 1;
+    }
+}
+__decorate([
+    args.string({ description: 'Source disk name' })
+], StorageMigrate.prototype, "from", void 0);
+__decorate([
+    args.string({ description: 'Target disk name' })
+], StorageMigrate.prototype, "to", void 0);
+__decorate([
+    flags.boolean({ description: 'List the files that would move without copying anything' })
+], StorageMigrate.prototype, "dryRun", void 0);

package/build/commands/ui.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+export default class Ui extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    action: string;
+    component: string;
+    preview: boolean;
+    accept: boolean;
+    run(): Promise<void>;
+    private initialize;
+}

package/build/commands/ui.js

@@ -0,0 +1,210 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseCommand, args, flags } from '@adonisjs/core/ace';
+import { createRequire } from 'node:module';
+import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import { dirname, join, resolve, relative, isAbsolute } from 'node:path';
+import { spawn } from 'node:child_process';
+import { digest } from '../src/commands/agent_assets.js';
+export default class Ui extends BaseCommand {
+    static commandName = 'adula:ui';
+    static description = 'Install reviewed RTL components through the project-owned shadcn registry';
+    async run() {
+        if (this.action !== 'add')
+            throw new Error('Usage: adula:ui add <component|all> [--preview|--accept]');
+        if (this.preview && this.accept)
+            throw new Error('Use either --preview or --accept, not both');
+        if (this.app.inProduction)
+            throw new Error('Install UI components in the source checkout');
+        const root = this.app.makePath();
+        const require = createRequire(this.app.makeURL('package.json'));
+        const uiRoot = dirname(require.resolve('@adula/ui/package.json'));
+        const manifest = JSON.parse(await readFile(join(uiRoot, 'build/manifest.json'), 'utf8'));
+        const available = new Set(manifest.items.map((item) => item.name));
+        if (this.component !== 'all' && !available.has(this.component))
+            throw new Error(`Unknown UI component: ${this.component}`);
+        const collected = new Map();
+        const load = async (name) => {
+            if (collected.has(name))
+                return;
+            if (!available.has(name))
+                throw new Error(`Unreviewed registry dependency: ${name}`);
+            const item = JSON.parse(await readFile(join(uiRoot, 'build', `${name}.json`), 'utf8'));
+            collected.set(name, item);
+            for (const dependency of item.registryDependencies ?? [])
+                await load(dependency);
+        };
+        for (const name of this.component === 'all' ? available : [this.component])
+            await load(name);
+        let lock = {
+            version: manifest.version,
+            kitCompatibility: manifest.kitCompatibility,
+            files: {},
+        };
+        try {
+            lock = JSON.parse(await readFile(this.app.makePath('ui.lock.json'), 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const customized = new Map();
+        for (const item of collected.values())
+            for (const file of item.files) {
+                const path = resolve(root, file.target);
+                const local = relative(root, path);
+                if (local.startsWith('..') ||
+                    isAbsolute(local) ||
+                    !file.target.startsWith('inertia/components/ui/'))
+                    throw new Error('Registry files must stay in inertia/components/ui');
+                try {
+                    const current = await readFile(path, 'utf8');
+                    if (digest(current) !== lock.files[file.target]?.hash) {
+                        // --accept is the documented end of a review: the developer merged by hand,
+                        // so the file stays exactly as it is and only its recorded hash moves.
+                        if (this.accept)
+                            customized.set(file.target, current);
+                        else if (!this.preview)
+                            throw new Error(`Project customized ${file.target}; review it with --preview, merge the changes, then re-run with --accept`);
+                    }
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+        if (!this.preview)
+            await this.initialize(uiRoot);
+        else
+            await access(this.app.makePath('components.json'));
+        const bundle = {
+            $schema: 'https://ui.shadcn.com/schema/registry-item.json',
+            name: 'adula-ui',
+            type: 'registry:ui',
+            dependencies: [
+                ...new Set([
+                    ...[...collected.values()].flatMap((item) => item.dependencies ?? []),
+                    ...['tw-animate-css', '@fontsource/noto-sans-arabic'].map((name) => `${name}@${manifest.dependencies[name]}`),
+                ]),
+            ],
+            files: [...collected.values()].flatMap((item) => item.files),
+        };
+        const bundlePath = this.app.tmpPath('adula-ui.json');
+        await mkdir(dirname(bundlePath), { recursive: true });
+        await writeFile(bundlePath, JSON.stringify(bundle, null, 2));
+        const command = require.resolve('shadcn');
+        const bundleArgument = `./${relative(root, bundlePath).replaceAll('\\', '/')}`;
+        await new Promise((done, reject) => {
+            const child = spawn(process.execPath, [
+                command,
+                'add',
+                bundleArgument,
+                '--yes',
+                ...(this.preview ? ['--dry-run'] : ['--overwrite']),
+            ], { cwd: root, stdio: 'inherit', shell: false });
+            child.once('error', reject);
+            child.once('exit', (code) => code === 0 ? done() : reject(new Error(`shadcn exited with ${code}`)));
+        });
+        if (this.preview)
+            return;
+        // shadcn overwrites unconditionally; reviewed customizations are put back untouched.
+        for (const [target, content] of customized)
+            await writeFile(this.app.makePath(target), content);
+        for (const item of collected.values())
+            for (const file of item.files)
+                lock.files[file.target] = {
+                    hash: digest(await readFile(this.app.makePath(file.target), 'utf8')),
+                    component: item.name,
+                };
+        lock.version = manifest.version;
+        lock.kitCompatibility = manifest.kitCompatibility;
+        await writeFile(this.app.makePath('ui.lock.json'), JSON.stringify(lock, null, 2) + '\n');
+        this.logger.success(`Installed ${collected.size} registry items; project file hashes recorded in ui.lock.json`);
+        if (customized.size)
+            this.logger.info(`Preserved ${customized.size} reviewed customization(s): ${[...customized.keys()].join(', ')}`);
+    }
+    async initialize(uiRoot) {
+        const root = this.app.makePath();
+        const create = async (path, content) => {
+            await mkdir(dirname(path), { recursive: true });
+            try {
+                await writeFile(path, content, { flag: 'wx' });
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+        };
+        await create(join(root, 'components.json'), JSON.stringify({
+            $schema: 'https://ui.shadcn.com/schema.json',
+            style: 'new-york',
+            rsc: false,
+            tsx: true,
+            rtl: true,
+            tailwind: {
+                config: '',
+                css: 'inertia/css/kit.css',
+                baseColor: 'neutral',
+                cssVariables: true,
+            },
+            aliases: {
+                components: '~/components',
+                ui: '~/components/ui',
+                utils: '~/lib/utils',
+                lib: '~/lib',
+                hooks: '~/hooks',
+            },
+            iconLibrary: 'lucide',
+        }, null, 2) + '\n');
+        await create(join(root, 'inertia/css/kit.css'), await readFile(join(uiRoot, 'build/theme.css'), 'utf8'));
+        await create(join(root, 'inertia/lib/utils.ts'), "export { cn } from 'cn'\n");
+        const tsPath = join(root, 'tsconfig.json');
+        const ts = JSON.parse(await readFile(tsPath, 'utf8'));
+        ts.compilerOptions ??= {};
+        ts.compilerOptions.paths = { ...ts.compilerOptions.paths, '~/*': ['./inertia/*'] };
+        await writeFile(tsPath, JSON.stringify(ts, null, 2) + '\n');
+        const cssPath = join(root, 'inertia/css/app.css');
+        const css = await readFile(cssPath, 'utf8');
+        if (!css.includes('/* adula:legacy-layer */'))
+            await writeFile(cssPath, `/* adula:legacy-layer */\n@layer theme, base, legacy, components, utilities;\n@layer legacy {\n${css}\n}\n`);
+        const codemods = await this.createCodemods();
+        // The framework codemod only supports an object config. A configured host
+        // may use a callback (for test aliases, for example); do not rewrite it.
+        const vite = await readFile(join(root, 'vite.config.ts'), 'utf8');
+        if (!vite.includes("from '@tailwindcss/vite'") && !vite.includes('from "@tailwindcss/vite"'))
+            await codemods.registerVitePlugin('tailwindcss()', [
+                { module: '@tailwindcss/vite', identifier: 'tailwindcss', isNamed: false },
+            ]);
+        const project = await codemods.getTsMorphProject();
+        if (!project)
+            throw new Error('UI installation requires @adonisjs/assembler');
+        const entry = project.addSourceFileAtPathIfExists(join(root, 'inertia/app.tsx'));
+        // One CSS entry fixes layer ordering in development and production bundlers.
+        const kitCssPath = join(root, 'inertia/css/kit.css');
+        const kitCss = await readFile(kitCssPath, 'utf8');
+        if (!kitCss.includes('@import "./app.css"'))
+            await writeFile(kitCssPath, `@layer theme, base, legacy, components, utilities;\n@import "./app.css";\n${kitCss}`);
+        entry.getImportDeclaration('./css/app.css')?.remove();
+        if (!entry.getImportDeclaration('./css/kit.css'))
+            entry.addImportDeclaration({ moduleSpecifier: './css/kit.css' });
+        await entry.save();
+    }
+}
+__decorate([
+    args.string()
+], Ui.prototype, "action", void 0);
+__decorate([
+    args.string()
+], Ui.prototype, "component", void 0);
+__decorate([
+    flags.boolean({ description: 'Show shadcn changes without modifying UI files' })
+], Ui.prototype, "preview", void 0);
+__decorate([
+    flags.boolean({
+        description: 'Keep already reviewed customizations, re-record their hashes and update others',
+    })
+], Ui.prototype, "accept", void 0);

package/build/configure.d.ts

@@ -0,0 +1,2 @@
+import type Configure from '@adonisjs/core/commands/configure';
+export declare function configure(command: Configure): Promise<void>;

package/build/configure.js

@@ -0,0 +1,79 @@
+/*
+|--------------------------------------------------------------------------
+| Configure hook
+|--------------------------------------------------------------------------
+|
+| The configure hook is called when someone runs "node ace configure <package>"
+| command. You are free to perform any operations inside this function to
+| configure the package.
+|
+| To make things easier, you have access to the underlying "Configure"
+| instance and you can use codemods to modify the source files.
+|
+*/
+import { readFile, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { stubsRoot } from './stubs/main.js';
+export async function configure(command) {
+    const pkgPath = command.app.makePath('package.json');
+    const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+    for (const dependency of ['@adonisjs/lucid', '@adonisjs/auth', '@adonisjs/session', '@adonisjs/shield', 'pg']) {
+        if (!pkg.dependencies?.[dependency])
+            throw new Error(`Install and configure ${dependency} before @adula/kit`);
+    }
+    const aliases = { '#modules/*': './app/modules/*.js', '#tests/*': './tests/*.js' };
+    for (const [key, target] of Object.entries(aliases)) {
+        if (pkg.imports?.[key] && pkg.imports[key] !== target)
+            throw new Error(`Conflicting package import ${key}`);
+    }
+    const dbPath = command.app.configPath('database.ts');
+    const databaseSource = await readFile(dbPath, 'utf8');
+    if (!/client:\s*['"]pg['"]/.test(databaseSource.replace(/\/\/[^\n]*/g, '')))
+        throw new Error('Configure PostgreSQL with node ace configure @adonisjs/lucid --db=postgres before @adula/kit');
+    const codemods = await command.createCodemods();
+    const project = await codemods.getTsMorphProject();
+    if (!project)
+        throw new Error('The host must have @adonisjs/assembler installed to configure kit');
+    const dbFile = project.addSourceFileAtPathIfExists(dbPath);
+    const dbExport = dbFile.getExportAssignments()[0];
+    if (!dbExport)
+        throw new Error('config/database.ts must have a default export');
+    if (!dbExport.getExpression().getText().startsWith('withKitDatabase(')) {
+        const kitImport = dbFile.getImportDeclaration('@adula/kit');
+        if (kitImport)
+            kitImport.addNamedImport('withKitDatabase');
+        else
+            dbFile.addImportDeclaration({ moduleSpecifier: '@adula/kit', namedImports: ['withKitDatabase'] });
+        const urlImport = dbFile.getImportDeclaration('node:url');
+        if (!urlImport?.getNamedImports().some((entry) => entry.getName() === 'fileURLToPath')) {
+            if (urlImport)
+                urlImport.addNamedImport('fileURLToPath');
+            else
+                dbFile.addImportDeclaration({ moduleSpecifier: 'node:url', namedImports: ['fileURLToPath'] });
+        }
+        dbExport.setExpression(`withKitDatabase(${dbExport.getExpression().getText()}, fileURLToPath(new URL('../', import.meta.url)))`);
+        await dbFile.save();
+    }
+    pkg.imports = { ...pkg.imports, ...aliases };
+    await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    codemods.overwriteExisting = false;
+    for (const stub of ['modules', 'service', 'controller', 'routes', 'resource_contract'])
+        await codemods.makeUsingStub(stubsRoot, `${stub}.stub`, {}, stub === 'resource_contract'
+            ? { contentsFromFile: fileURLToPath(new URL('./stubs/resource_contract.txt', import.meta.url)) } : undefined);
+    await codemods.updateRcFile((rc) => {
+        rc.addProvider('@adula/kit/provider').addCommand('@adula/kit/commands').addPreloadFile('#start/kit_routes');
+    });
+    if (!pkg.devDependencies?.['@japa/api-client'] && !pkg.dependencies?.['@japa/api-client']) {
+        const installed = await codemods.installPackages([{ name: '@japa/api-client@3.2.1', isDevDependency: true }]);
+        if (!installed)
+            throw new Error('Install @japa/api-client@3.2.1, then rerun configure');
+    }
+    for (const [name, path, args] of [
+        ['apiClient', '@japa/api-client', ''],
+        ['sessionApiClient', '@adonisjs/session/plugins/api_client', 'app'],
+        ['authApiClient', '@adonisjs/auth/plugins/api_client', 'app'],
+        ['shieldApiClient', '@adonisjs/shield/plugins/api_client', ''],
+    ])
+        await codemods.registerJapaPlugin(`${name}(${args})`, [{ module: path, isNamed: true, identifier: name }]);
+    command.logger.success('Kit configured. Run migration:run, create your user using the official auth flow, then ADULA_ADMIN_EMAIL=<email> node ace adula:install.');
+}

package/build/database/migrations/1770000000000_kit_core.d.ts

@@ -0,0 +1,5 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+export default class KitCore extends BaseSchema {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/build/database/migrations/1770000000000_kit_core.js

@@ -0,0 +1,10 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+import { createCoreSchema } from '../../src/database/schema.js';
+export default class KitCore extends BaseSchema {
+    async up() {
+        await createCoreSchema(this.db.getWriteClient());
+    }
+    async down() {
+        throw new Error('Kit migrations are additive. Restore a tested backup instead of rolling back.');
+    }
+}

package/build/database/migrations/1770000000001_kit_attachments.d.ts

@@ -0,0 +1,5 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+export default class KitAttachments extends BaseSchema {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/build/database/migrations/1770000000001_kit_attachments.js

@@ -0,0 +1,10 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+import { createAttachmentsSchema } from '../../src/database/schema.js';
+export default class KitAttachments extends BaseSchema {
+    async up() {
+        await createAttachmentsSchema(this.db.getWriteClient());
+    }
+    async down() {
+        throw new Error('Kit migrations are additive. Restore a tested backup instead of rolling back.');
+    }
+}

package/build/database/migrations/1770000000002_kit_saved_views.d.ts

@@ -0,0 +1,5 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+export default class KitSavedViews extends BaseSchema {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/build/database/migrations/1770000000002_kit_saved_views.js

@@ -0,0 +1,10 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+import { createSavedViewsSchema } from '../../src/database/schema.js';
+export default class KitSavedViews extends BaseSchema {
+    async up() {
+        await createSavedViewsSchema(this.db.getWriteClient());
+    }
+    async down() {
+        throw new Error('Kit migrations are additive. Restore a tested backup instead of rolling back.');
+    }
+}

package/build/database/migrations/1770000000003_kit_user_invitations.d.ts

@@ -0,0 +1,5 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+export default class extends BaseSchema {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/build/database/migrations/1770000000003_kit_user_invitations.js

@@ -0,0 +1,18 @@
+import { BaseSchema } from '@adonisjs/lucid/schema';
+export default class extends BaseSchema {
+    async up() {
+        this.schema.createTable('user_invitations', (table) => {
+            table.increments('id');
+            table.string('email', 254).notNullable().unique();
+            table.string('full_name', 120).notNullable();
+            table.string('token_hash', 64).notNullable().unique();
+            table.integer('invited_by').unsigned().references('id').inTable('users').onDelete('RESTRICT');
+            table.timestamp('expires_at', { useTz: true }).notNullable();
+            table.timestamp('accepted_at', { useTz: true }).nullable();
+            table.timestamp('created_at', { useTz: true }).notNullable().defaultTo(this.now());
+        });
+    }
+    async down() {
+        throw new Error('Kit migrations are additive. Restore a tested backup instead of rolling back.');
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,51 @@
+export { defineResource, columnName } from './src/resource/define_resource.js';
+export { configure } from './configure.js';
+export { withKitDatabase } from './src/database/configure.js';
+export { createResourceController } from './src/admin/controller.js';
+export type { ResourceRuntime, ResourceList, ResourceEditor, ResourceShow, ResourceChildren, ResourceLookups, ResourceActivity, } from './src/admin/controller.js';
+export type * from './src/admin/presentation.js';
+export { ResourceRegistry } from './src/resource/registry.js';
+export type * from './src/resource/types.js';
+export { buildAbility, canRecord, inOrgScope } from './src/auth/ability.js';
+export { packedResourceRules } from './src/auth/packed_rules.js';
+export type { Actor, Rule, KitAbility } from './src/auth/ability.js';
+export { ActorStore } from './src/auth/actor_store.js';
+export { accessibleBy, authorizationSql, conditionSql } from './src/auth/sql.js';
+export { ResourceService } from './src/admin/resource_service.js';
+export { serialize, writableInput, selectedFields } from './src/admin/contracts.js';
+export { KitError } from './src/admin/errors.js';
+export { createCoreSchema, createResourceTable, createAttachmentsSchema, createSavedViewsSchema, } from './src/database/schema.js';
+export { registerUpload, findAttachment, loadAttachments, claimAttachment, releaseAttachment, summarizeAttachment, attachmentUrl, isAttachmentId, isRelativeDiskPath, } from './src/attachments/attachment_service.js';
+export type { AttachmentRecord, AttachmentSummary, UploadInput, ClaimInput, } from './src/attachments/attachment_service.js';
+export { migrateStorage } from './src/attachments/storage_migrate.js';
+export type { StorageDisk, StorageMigrationOptions, StorageMigrationResult, } from './src/attachments/storage_migrate.js';
+export { diagnoseAttachments } from './src/attachments/doctor.js';
+export { Settings, sequence, notify } from './src/services/settings.js';
+export { uiPreferences, validateUiPreferences, UI_PREFERENCES_KEY, DEFAULT_UI_PREFERENCES, } from './src/core/ui_preferences.js';
+export type { UiPreferences, CalendarSystem, CalendarPreference, } from './src/core/ui_preferences.js';
+export { moveOrgUnit } from './src/org/org_service.js';
+export { publishOutbox, consumeEvent } from './src/events/outbox.js';
+export type { Jobs, DomainEvent, Listener } from './src/events/outbox.js';
+export { AdonisJobs } from './src/events/adonis_jobs.js';
+export { recordMutation } from './src/events/record_mutation.js';
+export { assessBackup, verifyBackup } from './src/services/backup.js';
+export type { BackupObject, BackupStatus } from './src/services/backup.js';
+export { ActivityAdmin, logActivity } from './src/core/activity.js';
+export type { ActivityEntry, ActivityFilters, ActivityPage, ActivityRow, } from './src/core/activity.js';
+export { RolesAdmin, ALL_SUBJECT_LABEL } from './src/core/roles.js';
+export type { RoleSummary, RoleDetail, RoleRule, RuleInput, RoleMatrix, MatrixSubject, MatrixField, } from './src/core/roles.js';
+export { UsersAdmin } from './src/core/users.js';
+export { UserInvitations, type InvitationDelivery } from './src/core/user_invitations.js';
+export type { UserSummary, UserPage, UserRoleAssignment, UserOrgUnit } from './src/core/users.js';
+export { OrgUnitsAdmin } from './src/core/org_units.js';
+export type { OrgUnitNode } from './src/core/org_units.js';
+export { SavedViews } from './src/core/saved_views.js';
+export type { SavedView, SavedViewQuery } from './src/core/saved_views.js';
+export { NotificationsAdmin } from './src/core/notifications.js';
+export type { Notification, NotificationPage } from './src/core/notifications.js';
+export { SettingsAdmin, isProtectedSetting, parseSettingValue, SETTING_SCOPES, PROTECTED_SETTING_KEYS, } from './src/core/settings.js';
+export type { SettingScope, SettingRow, SettingInput } from './src/core/settings.js';
+export { runtimeHealth, isBackupStale, backupStale, heartbeat, HEARTBEAT_MAX_AGE_MS, BACKUP_MAX_AGE_MS, } from './src/core/health.js';
+export type { RuntimeHealth, HeartbeatStatus, QueueSnapshot, QueueCounts, FailedJob, } from './src/core/health.js';
+export { MailDeliveryTest, MAIL_TEST_KEY, type MailTestState } from './src/core/mail_test.js';
+export { InitialSetup, type SetupCheck } from './src/core/setup.js';

package/build/index.js

@@ -0,0 +1,34 @@
+export { defineResource, columnName } from './src/resource/define_resource.js';
+export { configure } from './configure.js';
+export { withKitDatabase } from './src/database/configure.js';
+export { createResourceController } from './src/admin/controller.js';
+export { ResourceRegistry } from './src/resource/registry.js';
+export { buildAbility, canRecord, inOrgScope } from './src/auth/ability.js';
+export { packedResourceRules } from './src/auth/packed_rules.js';
+export { ActorStore } from './src/auth/actor_store.js';
+export { accessibleBy, authorizationSql, conditionSql } from './src/auth/sql.js';
+export { ResourceService } from './src/admin/resource_service.js';
+export { serialize, writableInput, selectedFields } from './src/admin/contracts.js';
+export { KitError } from './src/admin/errors.js';
+export { createCoreSchema, createResourceTable, createAttachmentsSchema, createSavedViewsSchema, } from './src/database/schema.js';
+export { registerUpload, findAttachment, loadAttachments, claimAttachment, releaseAttachment, summarizeAttachment, attachmentUrl, isAttachmentId, isRelativeDiskPath, } from './src/attachments/attachment_service.js';
+export { migrateStorage } from './src/attachments/storage_migrate.js';
+export { diagnoseAttachments } from './src/attachments/doctor.js';
+export { Settings, sequence, notify } from './src/services/settings.js';
+export { uiPreferences, validateUiPreferences, UI_PREFERENCES_KEY, DEFAULT_UI_PREFERENCES, } from './src/core/ui_preferences.js';
+export { moveOrgUnit } from './src/org/org_service.js';
+export { publishOutbox, consumeEvent } from './src/events/outbox.js';
+export { AdonisJobs } from './src/events/adonis_jobs.js';
+export { recordMutation } from './src/events/record_mutation.js';
+export { assessBackup, verifyBackup } from './src/services/backup.js';
+export { ActivityAdmin, logActivity } from './src/core/activity.js';
+export { RolesAdmin, ALL_SUBJECT_LABEL } from './src/core/roles.js';
+export { UsersAdmin } from './src/core/users.js';
+export { UserInvitations } from './src/core/user_invitations.js';
+export { OrgUnitsAdmin } from './src/core/org_units.js';
+export { SavedViews } from './src/core/saved_views.js';
+export { NotificationsAdmin } from './src/core/notifications.js';
+export { SettingsAdmin, isProtectedSetting, parseSettingValue, SETTING_SCOPES, PROTECTED_SETTING_KEYS, } from './src/core/settings.js';
+export { runtimeHealth, isBackupStale, backupStale, heartbeat, HEARTBEAT_MAX_AGE_MS, BACKUP_MAX_AGE_MS, } from './src/core/health.js';
+export { MailDeliveryTest, MAIL_TEST_KEY } from './src/core/mail_test.js';
+export { InitialSetup } from './src/core/setup.js';

package/build/providers/kit_provider.d.ts

@@ -0,0 +1,6 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+export default class KitProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    register(): void;
+}

package/build/providers/kit_provider.js

@@ -0,0 +1,10 @@
+import { ResourceRegistry } from '../src/resource/registry.js';
+export default class KitProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    register() {
+        this.app.container.singleton(ResourceRegistry, () => new ResourceRegistry());
+    }
+}

package/build/src/admin/contracts.d.ts

@@ -0,0 +1,12 @@
+import type { KitAbility, Actor } from '../auth/ability.js';
+import type { RecordData, Resource, JsonValue, SerializedRecord } from '../resource/types.js';
+export declare function selectedFields(resource: Resource, ability: KitAbility, options?: {
+    write?: boolean;
+    extra?: string[];
+}): string[];
+export declare function fromRow(row: RecordData, resource: Resource): RecordData;
+export declare function jsonValue(value: unknown): JsonValue;
+export declare function serialize(resource: Resource, record: RecordData, ability: KitAbility, actor: Actor): SerializedRecord;
+export declare function writableInput(resource: Resource, input: RecordData): {
+    [k: string]: unknown;
+};