@revoengine/cli 1.0.9 → 1.0.11

package/dist/src/cli.js

@@ -1,8 +1,8 @@
 import { realpathSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { RevoClient } from "./client.js";
-import { resolveRuntimeConfig } from "./config.js";
-import { handleAuthCommand, handleComponentCommand, handleEndpointsCommand, handleInfoCommand, handleProjectCommand, handleRequestCommand, handleSearchCommand, } from "./commands/index.js";
+import { getActiveEnvironmentName } from "./config.js";
+import { handleAuthCommand, handleComponentCommand, handleDatabaseSchemasCommand, handleDatabaseViewsCommand, handleEndpointsCommand, handleEnvCommand, handleEventsCommand, handleGroupsCommand, handleInfoCommand, handleJobTemplatesCommand, handleMetadataCommand, handleProjectCommand, handleRequestCommand, handleRoleGroupsCommand, handleSearchCommand, handleSchedulesCommand, handleTerminalCommand, } from "./commands/index.js";
 import { buildRuntimeViewModel } from "./runtime-view.js";
 import { renderHelp, renderOverview } from "./ui.js";
 import { maybeNotifyUpdateAvailable } from "./update-notifier.js";
@@ -136,23 +136,36 @@ function printError(error) {
     process.stderr.write(`${danger('Error:')} ${message}\n`);
 }
 function resolveClient(args) {
-    const runtime = resolveRuntimeConfig({
+    return new RevoClient({
         baseUrl: typeof args.url === 'string' ? args.url : typeof args.baseUrl === 'string' ? args.baseUrl : undefined,
         instance: typeof args.instance === 'string' ? args.instance : typeof args.i === 'string' ? args.i : undefined,
         token: typeof args.token === 'string' ? args.token : typeof args.t === 'string' ? args.t : undefined,
+        envName: typeof args.env === 'string' ? args.env : undefined,
     });
-    return new RevoClient(runtime);
 }
 function createContext(args) {
-    const client = resolveClient(args);
+    if (args.project !== undefined && args.env !== undefined) {
+        throw new Error('Use either --project or --env, not both.');
+    }
+    if (args.project !== undefined && (typeof args.project !== 'string' || !args.project.trim())) {
+        throw new Error('--project requires a saved project name.');
+    }
+    const active = getActiveEnvironmentName();
+    const selectedProject = args.project === undefined ? args.env : args.project;
+    const effectiveArgs = selectedProject === undefined && active !== 'default'
+        ? { ...args, env: active }
+        : args.project !== undefined ? { ...args, env: selectedProject } : args;
+    const client = resolveClient(effectiveArgs);
     return {
-        args,
+        args: effectiveArgs,
         client,
+        componentEnvironment: typeof effectiveArgs.env === 'string' ? effectiveArgs.env : undefined,
         cwd: process.cwd(),
         packageVersion,
         print,
         println,
         error: (message) => printError(new Error(message)),
+        warn: (message) => process.stderr.write(`Warning: ${message}\n`),
     };
 }
 function printHelp() {
@@ -188,14 +201,48 @@ export async function main(argv = process.argv.slice(2)) {
         await handleAuthCommand(context);
         return;
     }
+    if (command === 'terminal') {
+        const terminalIndex = argv.indexOf('terminal');
+        const terminalArgs = argv.slice(terminalIndex + 1);
+        const action = args._[1] || 'help';
+        const actionIndex = terminalArgs.indexOf(action);
+        if (actionIndex >= 0)
+            terminalArgs.splice(actionIndex, 1);
+        await handleTerminalCommand([action, ...argv.slice(0, terminalIndex), ...terminalArgs]);
+        return;
+    }
     if (command === 'component') {
         await handleComponentCommand(context);
         return;
     }
+    if (command === 'database-schemas') {
+        await handleDatabaseSchemasCommand(context);
+        return;
+    }
+    if (command === 'database-views') {
+        await handleDatabaseViewsCommand(context);
+        return;
+    }
     if (command === 'endpoints') {
         await handleEndpointsCommand(context);
         return;
     }
+    if (command === 'projects' || command === 'env') {
+        await handleEnvCommand(context);
+        return;
+    }
+    if (command === 'events') {
+        await handleEventsCommand(context);
+        return;
+    }
+    if (command === 'metadata') {
+        await handleMetadataCommand(context);
+        return;
+    }
+    if (command === 'job-templates') {
+        await handleJobTemplatesCommand(context);
+        return;
+    }
     if (command === 'project') {
         await handleProjectCommand(context);
         return;
@@ -208,6 +255,18 @@ export async function main(argv = process.argv.slice(2)) {
         await handleRequestCommand(context);
         return;
     }
+    if (command === 'role-groups') {
+        await handleRoleGroupsCommand(context);
+        return;
+    }
+    if (command === 'groups') {
+        await handleGroupsCommand(context);
+        return;
+    }
+    if (command === 'schedules') {
+        await handleSchedulesCommand(context);
+        return;
+    }
     throw new Error(`Unknown command: ${command}`);
 }
 if (isDirectExecution()) {

package/dist/src/client.d.ts

@@ -1,14 +1,266 @@
+import type { ComponentRecord, DatabaseSchemaRecord, DatabaseViewRecord, EndpointRecord, EventRecord, GroupRecord, JobTemplateRecord, RoleGroupRecord, ScheduleRecord } from './types.ts';
 export type RequestOptions = {
     query?: Record<string, unknown>;
     body?: unknown;
     headers?: HeadersInit;
     authGuard?: boolean;
     spinnerLabel?: string;
+    productionWrite?: boolean;
+    timeoutMs?: number;
+    /** Explicitly trusted service endpoint, such as the sandbox URL returned by /me. */
+    allowExternalOrigin?: boolean;
 };
-export type ComponentListRequest = {
+export type PaginatedListRequest = {
     path?: string;
     query?: Record<string, unknown>;
 };
+export type ComponentListRequest = PaginatedListRequest;
+export type DatabaseSchemaListRequest = PaginatedListRequest;
+export type DatabaseSchemaResponse = DatabaseSchemaRecord | {
+    data: DatabaseSchemaRecord;
+};
+export type DatabaseSchemaStatsRecord = {
+    databaseId: string;
+    name?: string;
+    type?: string;
+    size: {
+        total: number;
+        table: number;
+        indexes: number;
+        relations: number;
+        audit: number;
+    };
+};
+export type DatabaseSchemaMetadataWritePayload = {
+    version: number;
+    metadata: Record<string, unknown>;
+};
+export type DatabaseSchemaUpdatePayload = Omit<DatabaseSchemaMetadataWritePayload, 'metadata'> & {
+    metadata?: Record<string, unknown>;
+    category?: string;
+    desc?: string;
+    definition?: Record<string, unknown>[];
+};
+export type DatabaseSchemaCreatePayload = {
+    name: string;
+    category?: string | null;
+    desc?: string;
+    metadata: Record<string, unknown>;
+    definition?: Record<string, unknown>[];
+    partition?: Record<string, unknown>;
+    parent?: string;
+    audit?: false;
+    restricted?: false;
+};
+export type DatabaseViewPreviewPayload = ({
+    definitionMode: 'STRUCTURED';
+    request: Record<string, unknown>;
+} | {
+    definitionMode: 'RAW_SQL';
+    rawQuery: string;
+}) & {
+    take: 0;
+    output: {
+        take: 0;
+        count: false;
+    };
+};
+export type DatabaseViewCreatePayload = {
+    name: string;
+    category?: string | null;
+    desc?: string;
+    metadata: Record<string, unknown>;
+    type: 'VIEW' | 'MATERIALIZED_VIEW';
+    restricted: true;
+    users: [];
+    groups: [];
+    uniqueKey?: string[];
+    indexes?: Array<{
+        columns: Array<{
+            name: string;
+        }>;
+        unique?: boolean;
+    }>;
+} & ({
+    definitionMode: 'STRUCTURED';
+    request: Record<string, unknown>;
+} | {
+    definitionMode: 'RAW_SQL';
+    rawQuery: string;
+});
+export type DatabaseViewUpdatePayload = {
+    name: string;
+    category?: string | null;
+    desc?: string | null;
+    metadata: Record<string, unknown>;
+    type: 'VIEW' | 'MATERIALIZED_VIEW';
+    restricted: boolean;
+    users: string[];
+    groups: string[];
+    version: number;
+    uniqueKey?: string[];
+    indexes?: Array<{
+        name?: string;
+        columns: Array<{
+            name: string;
+        }>;
+        unique?: boolean;
+        [key: string]: unknown;
+    }>;
+} & ({
+    definitionMode: 'STRUCTURED';
+    request: Record<string, unknown>;
+} | {
+    definitionMode: 'RAW_SQL';
+    rawQuery: string;
+});
+export type EndpointListRequest = ComponentListRequest;
+export type EndpointWritePayload = {
+    version: number;
+    metadata: Record<string, unknown>;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    componentId?: string | null;
+    componentVersion?: number | null;
+    timeout?: number;
+    path?: string;
+    method?: string;
+    options?: Record<string, unknown> | null;
+};
+export type EndpointCreatePayload = Omit<EndpointWritePayload, 'version'> & {
+    name: string;
+    active: boolean;
+    path: string;
+    method: string;
+};
+export type RoleGroupListRequest = {
+    path?: string;
+    query?: Record<string, unknown>;
+};
+export type GroupListRequest = ComponentListRequest;
+export type JobTemplateListRequest = ComponentListRequest;
+export type JobTemplateResponse = JobTemplateRecord | {
+    data: JobTemplateRecord;
+};
+export type ScheduleListRequest = ComponentListRequest;
+export type ScheduleResponse = ScheduleRecord | {
+    data: ScheduleRecord;
+};
+export type EventListRequest = ComponentListRequest;
+export type EventResponse = EventRecord | {
+    data: EventRecord;
+};
+export type EventMetadataWritePayload = {
+    version: number;
+    metadata: Record<string, unknown>;
+};
+export type EventWritePayload = EventMetadataWritePayload & {
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    type?: string;
+    targetType?: string;
+    targetId?: string;
+    filter?: Record<string, unknown> | null;
+    [key: string]: unknown;
+};
+export type EventCreatePayload = Omit<EventWritePayload, 'version'> & {
+    name: string;
+    active: boolean;
+    type: string;
+    targetType: string;
+    targetId: string;
+};
+export type EventListAllOptions = {
+    includeDeleted?: boolean;
+};
+export type ScheduleWritePayload = {
+    version: number;
+    metadata: Record<string, unknown>;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    cron?: string;
+    timezone?: string;
+    targetType?: string;
+    targetId?: string;
+    targetVersion?: number | null;
+    targetConfig?: Record<string, unknown> | null;
+};
+export type ScheduleCreatePayload = {
+    name: string;
+    category?: string | null;
+    active: boolean;
+    desc?: string;
+    metadata: Record<string, unknown>;
+    cron: string;
+    timezone: string;
+    targetType: string;
+    targetId: string;
+    targetVersion?: number | null;
+    targetConfig?: Record<string, unknown> | null;
+};
+export type JobTemplateUpdatePayload = {
+    version: number;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    metadata?: Record<string, unknown>;
+    componentId?: string;
+    timeout?: number | null;
+    options?: unknown;
+    inputs?: unknown;
+};
+export type JobTemplateCreatePayload = {
+    name: string;
+    category?: string | null;
+    desc?: string;
+    metadata: Record<string, unknown>;
+    componentId: string;
+    timeout?: number;
+    options?: unknown;
+    inputs?: unknown;
+};
+export type RoleGroupResponse = RoleGroupRecord | {
+    data: RoleGroupRecord;
+};
+export type GroupResponse = GroupRecord | {
+    data: GroupRecord;
+};
+export type GroupWritePayload = {
+    version: number;
+    metadata: Record<string, unknown>;
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    ownerId?: string;
+    ownerType?: 'GROUP';
+};
+export type GroupCreatePayload = Omit<GroupWritePayload, 'version'> & {
+    name: string;
+    ownerId: string;
+    ownerType: 'GROUP';
+    members: string[];
+};
+export type RoleGroupWritePayload = {
+    name?: string;
+    category?: string | null;
+    desc?: string;
+    metadata: Record<string, unknown>;
+    version?: number;
+};
+export type RoleGroupCreatePayload = RoleGroupWritePayload & {
+    name: string;
+    roles: string[];
+};
+export type SystemRoleRecord = {
+    roleKey?: string;
+    key?: string;
+    name?: string;
+    code?: string;
+    [key: string]: unknown;
+};
 export type DebugStreamEvent = {
     event: string;
     data: unknown;
@@ -17,7 +269,15 @@ export type ClientOptions = {
     baseUrl?: string;
     instance?: string;
     token?: string;
+    envName?: string;
+    production?: true;
     fetch?: typeof fetch;
+    confirmProductionWrite?: (details: {
+        baseUrl: string;
+        method: string;
+        path: string;
+    }) => Promise<boolean>;
+    trustedServiceOrigins?: string[];
 };
 export type ApiResponse<T = unknown> = {
     status: number;
@@ -28,15 +288,17 @@ export type ApiResponse<T = unknown> = {
 export declare class ApiError extends Error {
     status: number;
     data: unknown;
-    constructor(status: number, message: string, data: unknown);
+    headers?: Headers;
+    constructor(status: number, message: string, data: unknown, headers?: Headers);
 }
 export declare class AuthenticationError extends ApiError {
-    constructor(status: number, message: string, data: unknown);
+    constructor(status: number, message: string, data: unknown, headers?: Headers);
 }
 export declare class PermissionDeniedError extends ApiError {
     path: string;
-    constructor(path: string, message: string, data: unknown);
+    constructor(path: string, message: string, data: unknown, headers?: Headers);
 }
+declare const COMPONENT_LIST_PAGE_SIZE = 200;
 declare function buildUrl(baseUrl: string, requestPath: string, query?: Record<string, unknown>): URL;
 declare function normalizeToken(token?: string): string;
 export declare function extractProfileInstanceId(profile: unknown): string;
@@ -44,7 +306,11 @@ export declare class RevoClient {
     baseUrl: string;
     instance: string;
     token: string;
+    production: boolean;
     fetchImpl: typeof fetch | undefined;
+    private productionWriteConfirmed;
+    private confirmProductionWrite;
+    private trustedServiceOrigins;
     constructor(options?: ClientOptions);
     get authHeader(): string;
     get authValidationKey(): string;
@@ -61,17 +327,112 @@ export declare class RevoClient {
         profile: unknown;
     }>;
     request(method: string, path: string, options?: RequestOptions): Promise<ApiResponse>;
+    private assertProductionWriteConfirmed;
     requestData<T = unknown>(method: string, path: string, options?: RequestOptions): Promise<T>;
     me(options?: {
         force?: boolean;
     }): Promise<unknown>;
-    listEndpoints(): Promise<unknown>;
+    listEndpoints(options?: EndpointListRequest): Promise<unknown>;
+    listDatabaseSchemas(options?: DatabaseSchemaListRequest): Promise<unknown>;
+    listAllDatabaseSchemas(options?: {
+        projection?: 'thin' | 'pull';
+        skipPartitions?: boolean;
+    }): Promise<{
+        databases: DatabaseSchemaRecord[];
+        discoveredTotal: number | null;
+    }>;
+    findActiveDatabaseSchemasByField(field: string, value: unknown, path?: Array<string | number>): Promise<DatabaseSchemaRecord[]>;
+    getDatabaseSchemaStats(): Promise<DatabaseSchemaStatsRecord[]>;
+    getDatabaseSchema(databaseId: string): Promise<DatabaseSchemaResponse>;
+    createDatabaseSchema(body: DatabaseSchemaCreatePayload): Promise<DatabaseSchemaResponse>;
+    updateDatabaseSchemaMetadata(databaseId: string, body: DatabaseSchemaMetadataWritePayload): Promise<DatabaseSchemaResponse>;
+    updateDatabaseSchema(databaseId: string, body: DatabaseSchemaUpdatePayload): Promise<DatabaseSchemaResponse>;
+    deleteDatabaseSchema(databaseId: string): Promise<unknown>;
+    listAllDatabaseViews(): Promise<DatabaseViewRecord[]>;
+    getDatabaseView(databaseViewId: string): Promise<DatabaseViewRecord | {
+        data: DatabaseViewRecord;
+    }>;
+    listAllDatabaseViewsForSync(): Promise<DatabaseViewRecord[]>;
+    previewDatabaseView(body: DatabaseViewPreviewPayload): Promise<unknown>;
+    createDatabaseView(body: DatabaseViewCreatePayload): Promise<DatabaseViewRecord | {
+        data: DatabaseViewRecord;
+    }>;
+    updateDatabaseView(databaseViewId: string, body: DatabaseViewUpdatePayload): Promise<DatabaseViewRecord | {
+        data: DatabaseViewRecord;
+    }>;
+    listAllEndpoints(): Promise<{
+        endpoints: EndpointRecord[];
+        discoveredTotal: number | null;
+    }>;
+    getEndpoint(endpointId: string): Promise<EndpointRecord>;
+    createEndpoint(body: EndpointCreatePayload): Promise<EndpointRecord>;
+    updateEndpoint(endpointId: string, body: EndpointWritePayload): Promise<EndpointRecord>;
+    activateEndpoint(endpointId: string): Promise<void>;
+    disableEndpoint(endpointId: string): Promise<void>;
+    restoreEndpoint(endpointId: string): Promise<void>;
+    getComponentSnapshotVersion(componentId: string, version: number): Promise<ComponentRecord>;
     getEditorTypes(requestPath?: string): Promise<unknown>;
     debugComponent(requestPath: string, body: unknown): Promise<unknown>;
     debugComponentStream(requestPath: string, body: unknown): AsyncGenerator<DebugStreamEvent>;
     search(params: Record<string, unknown>): Promise<unknown>;
     listComponents(options?: ComponentListRequest): Promise<unknown>;
+    listAllComponents(): Promise<{
+        components: Record<string, unknown>[];
+        discoveredTotal: number | null;
+    }>;
     getComponent(componentId: string): Promise<unknown>;
+    createComponent(body: unknown): Promise<unknown>;
+    updateComponent(componentId: string, body: unknown): Promise<unknown>;
+    deleteComponent(componentId: string): Promise<ApiResponse<unknown>>;
+    listRoleGroups(options?: RoleGroupListRequest): Promise<unknown>;
+    listAllRoleGroups(): Promise<{
+        roleGroups: RoleGroupRecord[];
+        discoveredTotal: number | null;
+    }>;
+    getRoleGroup(roleGroupId: string): Promise<RoleGroupResponse>;
+    listGroups(options?: GroupListRequest): Promise<unknown>;
+    listAllGroups(): Promise<{
+        groups: GroupRecord[];
+        discoveredTotal: number | null;
+    }>;
+    getGroup(groupId: string): Promise<GroupResponse>;
+    listJobTemplates(options?: JobTemplateListRequest): Promise<unknown>;
+    listAllJobTemplates(): Promise<{
+        jobTemplates: JobTemplateRecord[];
+        discoveredTotal: number | null;
+    }>;
+    getJobTemplate(jobTemplateId: string): Promise<JobTemplateResponse>;
+    createJobTemplate(body: JobTemplateCreatePayload): Promise<JobTemplateResponse>;
+    updateJobTemplate(jobTemplateId: string, body: JobTemplateUpdatePayload): Promise<JobTemplateResponse>;
+    listSchedules(options?: ScheduleListRequest): Promise<unknown>;
+    listAllSchedules(): Promise<{
+        schedules: ScheduleRecord[];
+        discoveredTotal: number | null;
+    }>;
+    getSchedule(scheduleId: string): Promise<ScheduleResponse>;
+    createSchedule(body: ScheduleCreatePayload): Promise<ScheduleResponse>;
+    updateSchedule(scheduleId: string, body: ScheduleWritePayload): Promise<ScheduleResponse>;
+    activateSchedule(scheduleId: string): Promise<unknown>;
+    listEvents(options?: EventListRequest): Promise<unknown>;
+    listAllEvents({ includeDeleted }?: EventListAllOptions): Promise<{
+        events: EventRecord[];
+        discoveredTotal: number | null;
+    }>;
+    getEvent(eventId: string): Promise<EventResponse>;
+    createEvent(body: EventCreatePayload): Promise<EventResponse>;
+    updateEvent(eventId: string, body: EventWritePayload): Promise<EventResponse>;
+    activateEvent(eventId: string): Promise<unknown>;
+    disableEvent(eventId: string): Promise<unknown>;
+    createRoleGroup(body: RoleGroupCreatePayload): Promise<RoleGroupResponse>;
+    updateRoleGroup(roleGroupId: string, body: RoleGroupWritePayload): Promise<RoleGroupResponse>;
+    updateGroup(groupId: string, body: GroupWritePayload): Promise<GroupResponse>;
+    createGroup(body: GroupCreatePayload): Promise<GroupResponse>;
+    addRoleGroupRole(roleGroupId: string, roleKey: string): Promise<unknown>;
+    removeRoleGroupRole(roleGroupId: string, roleKey: string): Promise<unknown>;
+    deleteRoleGroup(roleGroupId: string): Promise<ApiResponse<unknown>>;
+    listSystemRoles(): Promise<unknown>;
+    listAllSystemRoles(): Promise<SystemRoleRecord[]>;
     saveComponentElements(componentId: string, body: unknown): Promise<ApiResponse<unknown>>;
 }
+export { COMPONENT_LIST_PAGE_SIZE };
 export { buildUrl, normalizeToken };