@nlabs/reaktor 1.9.1 → 1.11.0

package/lib/actions/databaseAccounts.js

@@ -0,0 +1,211 @@
+import { Database } from 'arangojs';
+import { useDb } from '../utils/arangodbUtils.js';
+import { getDatabaseCredentialIdentity, parseDatabaseCredentialSecret } from '../utils/databaseCredentials.js';
+const managedBy = 'reaktor';
+const ownershipKeys = [
+    'appId',
+    'databaseName',
+    'environment',
+    'secretName',
+    'username'
+];
+// Never pass the caught error's request/body — only its message and ArangoDB error code, which never carry the password.
+const logFailure = (operation, error, context)=>{
+    const { errorNum, message, name } = error;
+    // eslint-disable-next-line no-console
+    console.error(`${operation} failed`, {
+        ...context,
+        errorNum,
+        message,
+        name
+    });
+};
+export const inspectDatabaseAccount = async (identity)=>{
+    const db = useDb('_system');
+    try {
+        const user = await db.getUser(identity.username);
+        const managed = user.active && user.extra?.managedBy === managedBy && ownershipKeys.every((key)=>user.extra[key] === identity[key]);
+        const grants = await db.getUserDatabases(identity.username);
+        return {
+            grants,
+            identity: getDatabaseCredentialIdentity(identity),
+            managed
+        };
+    } catch (error) {
+        if (error?.errorNum === 1703) {
+            return undefined;
+        }
+        logFailure('inspectDatabaseAccount', error, {
+            username: identity.username
+        });
+        throw new Error('database_account_inspection_failed');
+    }
+};
+const requireManaged = async (identity)=>{
+    if (!(await inspectDatabaseAccount(identity))?.managed) {
+        throw new Error('database_account_conflict');
+    }
+};
+export const createManagedDatabaseAccount = async (secret, beforeWrite)=>{
+    parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));
+    const existing = await inspectDatabaseAccount(secret);
+    if (existing) {
+        if (!existing.managed) {
+            throw new Error('database_account_conflict');
+        }
+        return;
+    }
+    await beforeWrite?.();
+    try {
+        await useDb('_system').createUser(secret.username, {
+            active: true,
+            extra: Object.fromEntries([
+                [
+                    'managedBy',
+                    managedBy
+                ],
+                ...ownershipKeys.map((key)=>[
+                        key,
+                        secret[key]
+                    ])
+            ]),
+            passwd: secret.password
+        });
+    } catch (error) {
+        // A lost response or concurrent create is safe only when ownership still matches.
+        if (!(await inspectDatabaseAccount(secret))?.managed) {
+            logFailure('createManagedDatabaseAccount', error, {
+                username: secret.username
+            });
+            throw new Error('database_account_conflict');
+        }
+    }
+};
+export const rotateManagedDatabaseAccountPassword = async (secret, beforeWrite)=>{
+    parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));
+    await requireManaged(secret);
+    await beforeWrite?.();
+    try {
+        await useDb('_system').updateUser(secret.username, secret.password);
+    } catch (error) {
+        logFailure('rotateManagedDatabaseAccountPassword', error, {
+            username: secret.username
+        });
+        throw new Error('database_account_grants_failed');
+    }
+};
+export const restrictDatabaseAccount = async (secret, beforeWrite)=>{
+    parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));
+    await requireManaged(secret);
+    const db = useDb('_system');
+    let permissions;
+    let databases;
+    let collections;
+    try {
+        permissions = await db.getUserDatabases(secret.username, true);
+        databases = await db.listDatabases();
+        collections = await useDb(secret.databaseName).listCollections();
+    } catch (error) {
+        logFailure('restrictDatabaseAccount:read', error, {
+            databaseName: secret.databaseName,
+            username: secret.username
+        });
+        throw new Error('database_account_grants_failed');
+    }
+    const writeGrant = async (database, grant, collection)=>{
+        await beforeWrite?.();
+        try {
+            await db.setUserAccessLevel(secret.username, {
+                collection,
+                database
+            }, grant);
+        } catch (error) {
+            logFailure('restrictDatabaseAccount:writeGrant', error, {
+                collection,
+                database,
+                username: secret.username
+            });
+            throw new Error('database_account_grants_failed');
+        }
+    };
+    // Explicitly deny old grants as well as current databases. Never inherit foreign privileges.
+    for (const database of new Set([
+        '*',
+        '_system',
+        ...Object.keys(permissions),
+        ...databases
+    ])){
+        if (database === secret.databaseName) {
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await writeGrant(database, 'none');
+        // ArangoDB refuses any rights change on a system collection (e.g. `_users`), even to deny it.
+        for (const collection of new Set([
+            '*',
+            ...Object.keys(permissions[database]?.collections ?? {}).filter((name)=>!name.startsWith('_'))
+        ])){
+            // eslint-disable-next-line no-await-in-loop
+            await writeGrant(database, 'none', collection);
+        }
+    }
+    await writeGrant(secret.databaseName, 'rw');
+    await writeGrant(secret.databaseName, 'none', '*');
+    for (const collection of collections){
+        // eslint-disable-next-line no-await-in-loop
+        await writeGrant(secret.databaseName, 'rw', collection.name);
+    }
+};
+export const verifyDatabaseAccount = async (secret)=>{
+    await requireManaged(secret);
+    parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));
+    const db = useDb('_system');
+    const client = new Database({
+        auth: {
+            password: secret.password,
+            username: secret.username
+        },
+        databaseName: secret.databaseName,
+        url: `${secret.host}:${secret.port}`
+    });
+    try {
+        const permissions = await db.getUserDatabases(secret.username, true);
+        const databases = await db.listDatabases();
+        for (const database of new Set([
+            '*',
+            '_system',
+            secret.databaseName,
+            ...Object.keys(permissions),
+            ...databases
+        ])){
+            // GET permission endpoints resolve effective access, unlike the raw full grant listing.
+            // eslint-disable-next-line no-await-in-loop
+            const access = await db.getUserAccessLevel(secret.username, {
+                database
+            });
+            if (access !== (database === secret.databaseName ? 'rw' : 'none')) {
+                throw new Error();
+            }
+        }
+        for (const collection of (await useDb(secret.databaseName).listCollections())){
+            // eslint-disable-next-line no-await-in-loop
+            if (await db.getUserAccessLevel(secret.username, {
+                collection: collection.name,
+                database: secret.databaseName
+            }) !== 'rw') {
+                throw new Error();
+            }
+        }
+        await (await client.query('RETURN 1')).all();
+    } catch (error) {
+        logFailure('verifyDatabaseAccount', error, {
+            databaseName: secret.databaseName,
+            username: secret.username
+        });
+        throw new Error('database_account_verification_failed');
+    } finally{
+        client.close();
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/databaseAccounts.ts"],"sourcesContent":["import {Database} from 'arangojs';\n\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {getDatabaseCredentialIdentity, parseDatabaseCredentialSecret} from '../utils/databaseCredentials.js';\n\nimport type {DatabaseCredentialIdentity, DatabaseCredentialSecret} from '../types/databaseCredentials.types.js';\n\ntype Access = 'none' | 'ro' | 'rw';\ntype BeforeWrite = () => Promise<void>;\ntype Account = {grants: Readonly<Record<string, Access>>; identity: DatabaseCredentialIdentity; managed: boolean};\nconst managedBy = 'reaktor';\nconst ownershipKeys = ['appId', 'databaseName', 'environment', 'secretName', 'username'] as const;\n\n// Never pass the caught error's request/body — only its message and ArangoDB error code, which never carry the password.\nconst logFailure = (operation: string, error: unknown, context: Record<string, unknown>): void => {\n  const {errorNum, message, name} = error as {errorNum?: unknown; message?: unknown; name?: unknown};\n  // eslint-disable-next-line no-console\n  console.error(`${operation} failed`, {...context, errorNum, message, name});\n};\n\nexport const inspectDatabaseAccount = async (identity: DatabaseCredentialIdentity): Promise<Account | undefined> => {\n  const db = useDb('_system');\n  try {\n    const user = await db.getUser(identity.username);\n    const managed = user.active && user.extra?.managedBy === managedBy\n      && ownershipKeys.every((key) => user.extra[key] === identity[key]);\n    const grants = await db.getUserDatabases(identity.username);\n    return {grants, identity: getDatabaseCredentialIdentity(identity), managed};\n  } catch(error) {\n    if((error as {errorNum?: number})?.errorNum === 1703) {\n      return undefined;\n    }\n    logFailure('inspectDatabaseAccount', error, {username: identity.username});\n    throw new Error('database_account_inspection_failed');\n  }\n};\n\nconst requireManaged = async (identity: DatabaseCredentialIdentity): Promise<void> => {\n  if(!(await inspectDatabaseAccount(identity))?.managed) {\n    throw new Error('database_account_conflict');\n  }\n};\n\nexport const createManagedDatabaseAccount = async (\n  secret: DatabaseCredentialSecret, beforeWrite?: BeforeWrite\n): Promise<void> => {\n  parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));\n  const existing = await inspectDatabaseAccount(secret);\n  if(existing) {\n    if(!existing.managed) {\n      throw new Error('database_account_conflict');\n    }\n    return;\n  }\n  await beforeWrite?.();\n  try {\n    await useDb('_system').createUser(secret.username, {\n      active: true,\n      extra: Object.fromEntries([['managedBy', managedBy], ...ownershipKeys.map((key) => [key, secret[key]])]),\n      passwd: secret.password\n    });\n  } catch(error) {\n    // A lost response or concurrent create is safe only when ownership still matches.\n    if(!(await inspectDatabaseAccount(secret))?.managed) {\n      logFailure('createManagedDatabaseAccount', error, {username: secret.username});\n      throw new Error('database_account_conflict');\n    }\n  }\n};\n\nexport const rotateManagedDatabaseAccountPassword = async (\n  secret: DatabaseCredentialSecret, beforeWrite?: BeforeWrite\n): Promise<void> => {\n  parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));\n  await requireManaged(secret);\n  await beforeWrite?.();\n  try {\n    await useDb('_system').updateUser(secret.username, secret.password);\n  } catch(error) {\n    logFailure('rotateManagedDatabaseAccountPassword', error, {username: secret.username});\n    throw new Error('database_account_grants_failed');\n  }\n};\n\nexport const restrictDatabaseAccount = async (\n  secret: DatabaseCredentialSecret, beforeWrite?: BeforeWrite\n): Promise<void> => {\n  parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));\n  await requireManaged(secret);\n  const db = useDb('_system');\n  let permissions: Awaited<ReturnType<typeof db.getUserDatabases>>;\n  let databases: string[];\n  let collections: {name: string}[];\n  try {\n    permissions = await db.getUserDatabases(secret.username, true);\n    databases = await db.listDatabases();\n    collections = await useDb(secret.databaseName).listCollections();\n  } catch(error) {\n    logFailure('restrictDatabaseAccount:read', error, {databaseName: secret.databaseName, username: secret.username});\n    throw new Error('database_account_grants_failed');\n  }\n  const writeGrant = async (database: string, grant: Access, collection?: string): Promise<void> => {\n    await beforeWrite?.();\n    try {\n      await db.setUserAccessLevel(secret.username, {collection, database}, grant);\n    } catch(error) {\n      logFailure('restrictDatabaseAccount:writeGrant', error, {collection, database, username: secret.username});\n      throw new Error('database_account_grants_failed');\n    }\n  };\n  // Explicitly deny old grants as well as current databases. Never inherit foreign privileges.\n  for(const database of new Set(['*', '_system', ...Object.keys(permissions), ...databases])) {\n    if(database === secret.databaseName) {\n      continue;\n    }\n    // eslint-disable-next-line no-await-in-loop\n    await writeGrant(database, 'none');\n    // ArangoDB refuses any rights change on a system collection (e.g. `_users`), even to deny it.\n    for(const collection of new Set(['*', ...Object.keys(permissions[database]?.collections ?? {}).filter((name) => !name.startsWith('_'))])) {\n      // eslint-disable-next-line no-await-in-loop\n      await writeGrant(database, 'none', collection);\n    }\n  }\n  await writeGrant(secret.databaseName, 'rw');\n  await writeGrant(secret.databaseName, 'none', '*');\n  for(const collection of collections) {\n    // eslint-disable-next-line no-await-in-loop\n    await writeGrant(secret.databaseName, 'rw', collection.name);\n  }\n};\n\nexport const verifyDatabaseAccount = async (secret: DatabaseCredentialSecret): Promise<void> => {\n  await requireManaged(secret);\n  parseDatabaseCredentialSecret(secret, getDatabaseCredentialIdentity(secret));\n  const db = useDb('_system');\n  const client = new Database({\n    auth: {password: secret.password, username: secret.username},\n    databaseName: secret.databaseName,\n    url: `${secret.host}:${secret.port}`\n  });\n  try {\n    const permissions = await db.getUserDatabases(secret.username, true);\n    const databases = await db.listDatabases();\n    for(const database of new Set(['*', '_system', secret.databaseName, ...Object.keys(permissions), ...databases])) {\n      // GET permission endpoints resolve effective access, unlike the raw full grant listing.\n      // eslint-disable-next-line no-await-in-loop\n      const access = await db.getUserAccessLevel(secret.username, {database});\n      if(access !== (database === secret.databaseName ? 'rw' : 'none')) {\n        throw new Error();\n      }\n    }\n    for(const collection of await useDb(secret.databaseName).listCollections()) {\n      // eslint-disable-next-line no-await-in-loop\n      if(await db.getUserAccessLevel(secret.username, {collection: collection.name, database: secret.databaseName}) !== 'rw') {\n        throw new Error();\n      }\n    }\n    await (await client.query('RETURN 1')).all();\n  } catch(error) {\n    logFailure('verifyDatabaseAccount', error, {databaseName: secret.databaseName, username: secret.username});\n    throw new Error('database_account_verification_failed');\n  } finally {\n    client.close();\n  }\n};\n"],"names":["Database","useDb","getDatabaseCredentialIdentity","parseDatabaseCredentialSecret","managedBy","ownershipKeys","logFailure","operation","error","context","errorNum","message","name","console","inspectDatabaseAccount","identity","db","user","getUser","username","managed","active","extra","every","key","grants","getUserDatabases","undefined","Error","requireManaged","createManagedDatabaseAccount","secret","beforeWrite","existing","createUser","Object","fromEntries","map","passwd","password","rotateManagedDatabaseAccountPassword","updateUser","restrictDatabaseAccount","permissions","databases","collections","listDatabases","databaseName","listCollections","writeGrant","database","grant","collection","setUserAccessLevel","Set","keys","filter","startsWith","verifyDatabaseAccount","client","auth","url","host","port","access","getUserAccessLevel","query","all","close"],"mappings":"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"}

package/lib/actions/databaseProvisioningLease.d.ts

@@ -0,0 +1,6 @@
+import type { ApiContext } from '../types/auth.types.js';
+import type { DatabaseConnectionMetadata, DatabaseCredentialIdentity, DatabaseProvisioningLease } from '../types/databaseCredentials.types.js';
+export declare const acquireDatabaseProvisioningLease: (context: ApiContext, identity: DatabaseCredentialIdentity) => Promise<DatabaseProvisioningLease>;
+export declare const renewDatabaseProvisioningLease: (context: ApiContext, lease: DatabaseProvisioningLease) => Promise<DatabaseProvisioningLease>;
+export declare const releaseDatabaseProvisioningLease: (context: ApiContext, lease: DatabaseProvisioningLease) => Promise<void>;
+export declare const saveDatabaseProvisioningState: (context: ApiContext, lease: DatabaseProvisioningLease, metadata: DatabaseConnectionMetadata) => Promise<void>;

package/lib/actions/databaseProvisioningLease.js

@@ -0,0 +1,166 @@
+import { randomUUID } from 'node:crypto';
+import { useDb } from '../utils/arangodbUtils.js';
+const collectionName = 'databaseProvisioningLeases';
+const ttlMs = 120_000;
+const collectionBind = {
+    '@collection': collectionName
+};
+const getControlDb = (context)=>{
+    if (!context.databaseName) {
+        throw new Error('database_provisioning_control_database_required');
+    }
+    return useDb(context.databaseName);
+};
+const isErrorNumber = (error, ...codes)=>codes.includes(error?.errorNum ?? -1);
+const toLease = (row)=>({
+        expiresAt: row.expiresAt,
+        // eslint-disable-next-line no-underscore-dangle
+        key: row._key,
+        owner: row.owner
+    });
+const runQuery = async (context, query, bindVars)=>{
+    const cursor = await getControlDb(context).query({
+        bindVars: {
+            ...collectionBind,
+            ...bindVars
+        },
+        query
+    });
+    return cursor.all();
+};
+const fencedQuery = `
+  FOR doc IN @@collection
+    FILTER doc._key == @key AND doc.owner == @owner AND doc.expiresAt > DATE_NOW()
+    UPDATE {_key: doc._key, _rev: doc._rev} WITH `;
+export const acquireDatabaseProvisioningLease = async (context, identity)=>{
+    const key = `${identity.appId}-${identity.environment}`;
+    const owner = randomUUID();
+    if (!context.databaseName) {
+        throw new Error('database_provisioning_control_database_required');
+    }
+    try {
+        await getControlDb(context).collection(collectionName).create();
+    } catch (error) {
+        if (!isErrorNumber(error, 1207)) {
+            throw new Error('database_provisioning_error');
+        }
+    }
+    try {
+        const rows = await runQuery(context, `
+      INSERT {_key: @key, owner: @owner, expiresAt: DATE_NOW() + @ttlMs}
+      INTO @@collection RETURN NEW
+    `, {
+            key,
+            owner,
+            ttlMs
+        });
+        return toLease(rows[0]);
+    } catch (error) {
+        if (!isErrorNumber(error, 1210)) {
+            throw new Error('database_provisioning_error');
+        }
+    }
+    for(let attempt = 0; attempt < 3; attempt++){
+        try {
+            // A write conflict means another owner may have taken over; retry the fenced update.
+            // eslint-disable-next-line no-await-in-loop
+            const rows = await runQuery(context, `
+        FOR doc IN @@collection
+          FILTER doc._key == @key AND doc.expiresAt <= DATE_NOW()
+          UPDATE {_key: doc._key, _rev: doc._rev} WITH
+            {owner: @owner, expiresAt: DATE_NOW() + @ttlMs}
+          IN @@collection OPTIONS {ignoreRevs: false}
+          RETURN NEW
+      `, {
+                key,
+                owner,
+                ttlMs
+            });
+            if (rows[0]) {
+                return toLease(rows[0]);
+            }
+            throw new Error('database_provisioning_busy');
+        } catch (error) {
+            if (isErrorNumber(error, 1200) && attempt < 2) {
+                continue;
+            }
+            if (error instanceof Error && error.message === 'database_provisioning_busy') {
+                throw error;
+            }
+            throw new Error('database_provisioning_error');
+        }
+    }
+    throw new Error('database_provisioning_busy');
+};
+export const renewDatabaseProvisioningLease = async (context, lease)=>{
+    try {
+        const rows = await runQuery(context, `${fencedQuery}
+      {expiresAt: DATE_NOW() + @ttlMs}
+      IN @@collection OPTIONS {ignoreRevs: false} RETURN NEW
+    `, {
+            key: lease.key,
+            owner: lease.owner,
+            ttlMs
+        });
+        if (!rows[0]) {
+            throw new Error('database_provisioning_lease_lost');
+        }
+        return toLease(rows[0]);
+    } catch (error) {
+        if (error instanceof Error && error.message === 'database_provisioning_lease_lost') {
+            throw error;
+        }
+        throw new Error('database_provisioning_error');
+    }
+};
+export const releaseDatabaseProvisioningLease = async (context, lease)=>{
+    try {
+        const rows = await runQuery(context, `${fencedQuery}
+      {owner: null, expiresAt: 0}
+      IN @@collection OPTIONS {ignoreRevs: false} RETURN NEW
+    `, {
+            key: lease.key,
+            owner: lease.owner
+        });
+        if (!rows[0]) {
+            throw new Error('database_provisioning_lease_lost');
+        }
+    } catch (error) {
+        if (error instanceof Error && error.message === 'database_provisioning_lease_lost') {
+            throw error;
+        }
+        throw new Error('database_provisioning_error');
+    }
+};
+export const saveDatabaseProvisioningState = async (context, lease, metadata)=>{
+    const safeMetadata = {
+        appId: metadata.appId,
+        databaseName: metadata.databaseName,
+        environment: metadata.environment,
+        host: metadata.host,
+        port: metadata.port,
+        secretArn: metadata.secretArn,
+        secretName: metadata.secretName,
+        status: metadata.status,
+        username: metadata.username
+    };
+    try {
+        const rows = await runQuery(context, `${fencedQuery}
+      @metadata IN @@collection OPTIONS {ignoreRevs: false} RETURN NEW
+    `, {
+            key: lease.key,
+            metadata: safeMetadata,
+            owner: lease.owner
+        });
+        if (!rows[0]) {
+            throw new Error('database_provisioning_lease_lost');
+        }
+    } catch (error) {
+        if (error instanceof Error && error.message === 'database_provisioning_lease_lost') {
+            throw error;
+        }
+        throw new Error('database_provisioning_error');
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/databaseProvisioningLease.ts"],"sourcesContent":["import {randomUUID} from 'node:crypto';\n\nimport {useDb} from '../utils/arangodbUtils.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {DatabaseConnectionMetadata, DatabaseCredentialIdentity, DatabaseProvisioningLease} from '../types/databaseCredentials.types.js';\n\nconst collectionName = 'databaseProvisioningLeases';\nconst ttlMs = 120_000;\nconst collectionBind = {'@collection': collectionName};\n\ntype LeaseRow = {_key: string; owner: string; expiresAt: number};\ntype DatabaseError = {errorNum?: number};\n\nconst getControlDb = (context: ApiContext) => {\n  if(!context.databaseName) {\n    throw new Error('database_provisioning_control_database_required');\n  }\n  return useDb(context.databaseName);\n};\n\nconst isErrorNumber = (error: unknown, ...codes: number[]): boolean =>\n  codes.includes((error as DatabaseError | null)?.errorNum ?? -1);\n\nconst toLease = (row: LeaseRow): DatabaseProvisioningLease => ({\n  expiresAt: row.expiresAt,\n  // eslint-disable-next-line no-underscore-dangle\n  key: row._key,\n  owner: row.owner\n});\n\nconst runQuery = async (context: ApiContext, query: string, bindVars: Record<string, unknown>): Promise<LeaseRow[]> => {\n  const cursor = await getControlDb(context).query<LeaseRow>({bindVars: {...collectionBind, ...bindVars}, query});\n  return cursor.all();\n};\n\nconst fencedQuery = `\n  FOR doc IN @@collection\n    FILTER doc._key == @key AND doc.owner == @owner AND doc.expiresAt > DATE_NOW()\n    UPDATE {_key: doc._key, _rev: doc._rev} WITH `;\n\nexport const acquireDatabaseProvisioningLease = async (\n  context: ApiContext,\n  identity: DatabaseCredentialIdentity\n): Promise<DatabaseProvisioningLease> => {\n  const key = `${identity.appId}-${identity.environment}`;\n  const owner = randomUUID();\n  if(!context.databaseName) {\n    throw new Error('database_provisioning_control_database_required');\n  }\n  try {\n    await getControlDb(context).collection(collectionName).create();\n  } catch(error) {\n    if(!isErrorNumber(error, 1207)) {\n      throw new Error('database_provisioning_error');\n    }\n  }\n  try {\n    const rows = await runQuery(context, `\n      INSERT {_key: @key, owner: @owner, expiresAt: DATE_NOW() + @ttlMs}\n      INTO @@collection RETURN NEW\n    `, {key, owner, ttlMs});\n    return toLease(rows[0]);\n  } catch(error) {\n    if(!isErrorNumber(error, 1210)) {\n      throw new Error('database_provisioning_error');\n    }\n  }\n  for(let attempt = 0; attempt < 3; attempt++) {\n    try {\n      // A write conflict means another owner may have taken over; retry the fenced update.\n      // eslint-disable-next-line no-await-in-loop\n      const rows = await runQuery(context, `\n        FOR doc IN @@collection\n          FILTER doc._key == @key AND doc.expiresAt <= DATE_NOW()\n          UPDATE {_key: doc._key, _rev: doc._rev} WITH\n            {owner: @owner, expiresAt: DATE_NOW() + @ttlMs}\n          IN @@collection OPTIONS {ignoreRevs: false}\n          RETURN NEW\n      `, {key, owner, ttlMs});\n      if(rows[0]) {\n        return toLease(rows[0]);\n      }\n      throw new Error('database_provisioning_busy');\n    } catch(error) {\n      if(isErrorNumber(error, 1200) && attempt < 2) {\n        continue;\n      }\n      if(error instanceof Error && error.message === 'database_provisioning_busy') {\n        throw error;\n      }\n      throw new Error('database_provisioning_error');\n    }\n  }\n  throw new Error('database_provisioning_busy');\n};\n\nexport const renewDatabaseProvisioningLease = async (\n  context: ApiContext,\n  lease: DatabaseProvisioningLease\n): Promise<DatabaseProvisioningLease> => {\n  try {\n    const rows = await runQuery(context, `${fencedQuery}\n      {expiresAt: DATE_NOW() + @ttlMs}\n      IN @@collection OPTIONS {ignoreRevs: false} RETURN NEW\n    `, {key: lease.key, owner: lease.owner, ttlMs});\n    if(!rows[0]) {\n      throw new Error('database_provisioning_lease_lost');\n    }\n    return toLease(rows[0]);\n  } catch(error) {\n    if(error instanceof Error && error.message === 'database_provisioning_lease_lost') {\n      throw error;\n    }\n    throw new Error('database_provisioning_error');\n  }\n};\n\nexport const releaseDatabaseProvisioningLease = async (\n  context: ApiContext,\n  lease: DatabaseProvisioningLease\n): Promise<void> => {\n  try {\n    const rows = await runQuery(context, `${fencedQuery}\n      {owner: null, expiresAt: 0}\n      IN @@collection OPTIONS {ignoreRevs: false} RETURN NEW\n    `, {key: lease.key, owner: lease.owner});\n    if(!rows[0]) {\n      throw new Error('database_provisioning_lease_lost');\n    }\n  } catch(error) {\n    if(error instanceof Error && error.message === 'database_provisioning_lease_lost') {\n      throw error;\n    }\n    throw new Error('database_provisioning_error');\n  }\n};\n\nexport const saveDatabaseProvisioningState = async (\n  context: ApiContext,\n  lease: DatabaseProvisioningLease,\n  metadata: DatabaseConnectionMetadata\n): Promise<void> => {\n  const safeMetadata = {\n    appId: metadata.appId,\n    databaseName: metadata.databaseName,\n    environment: metadata.environment,\n    host: metadata.host,\n    port: metadata.port,\n    secretArn: metadata.secretArn,\n    secretName: metadata.secretName,\n    status: metadata.status,\n    username: metadata.username\n  };\n  try {\n    const rows = await runQuery(context, `${fencedQuery}\n      @metadata IN @@collection OPTIONS {ignoreRevs: false} RETURN NEW\n    `, {key: lease.key, metadata: safeMetadata, owner: lease.owner});\n    if(!rows[0]) {\n      throw new Error('database_provisioning_lease_lost');\n    }\n  } catch(error) {\n    if(error instanceof Error && error.message === 'database_provisioning_lease_lost') {\n      throw error;\n    }\n    throw new Error('database_provisioning_error');\n  }\n};\n"],"names":["randomUUID","useDb","collectionName","ttlMs","collectionBind","getControlDb","context","databaseName","Error","isErrorNumber","error","codes","includes","errorNum","toLease","row","expiresAt","key","_key","owner","runQuery","query","bindVars","cursor","all","fencedQuery","acquireDatabaseProvisioningLease","identity","appId","environment","collection","create","rows","attempt","message","renewDatabaseProvisioningLease","lease","releaseDatabaseProvisioningLease","saveDatabaseProvisioningState","metadata","safeMetadata","host","port","secretArn","secretName","status","username"],"mappings":"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"}

package/lib/actions/higgsfield.d.ts

@@ -18,3 +18,5 @@ export declare const generateSeedanceReferenceVideo: (context: ApiContext, input
 export declare const generateMarketingStudioImage: (context: ApiContext, input: MarketingStudioImageInput, webhookUrl?: string) => Promise<HiggsfieldRequestResult>;
 export declare const getHiggsfieldRequestStatus: (context: ApiContext, requestId: string) => Promise<HiggsfieldStatusResult>;
 export declare const cancelHiggsfieldRequest: (context: ApiContext, requestId: string) => Promise<boolean>;
+/** Submit one allowlisted catalog model; never retry a submission with an unknown outcome. */
+export declare const generateHiggsfieldModel: (context: ApiContext, modelId: string, input: Record<string, unknown>, webhookUrl?: string) => Promise<HiggsfieldRequestResult>;

package/lib/actions/higgsfield.js

@@ -3,6 +3,8 @@
  * All rights reserved. Use is subject to the accompanying commercial LICENSE.
  */ import { get, post } from '@nlabs/rip-hunter';
 import { validateMarketingStudioImageInput, validateSeedanceReferenceVideoInput, validateSeedanceVideoInput, validateSoulImageInput } from '../adapters/higgsfieldAdapter.js';
+import { getHiggsfieldModel } from '../adapters/higgsfieldModelCatalog.js';
+import { validateHiggsfieldModelInput } from '../adapters/higgsfieldModels.js';
 import { Config } from '../config.js';
 import { ErrorTypes } from '../types/error.types.js';
 import { logError } from '../utils/analyticsUtils.js';
@@ -144,5 +146,9 @@ export const cancelHiggsfieldRequest = async (context, requestId)=>{
         }, error, context);
     }
 };
+/** Submit one allowlisted catalog model; never retry a submission with an unknown outcome. */ export const generateHiggsfieldModel = (context, modelId, input, webhookUrl)=>{
+    const model = getHiggsfieldModel(modelId);
+    return submit(context, 'generateHiggsfieldModel', withWebhook(`${HIGGSFIELD_ORIGIN}/${model.id}`, webhookUrl), validateHiggsfieldModelInput(modelId, input));
+};
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/higgsfield.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {get, post} from '@nlabs/rip-hunter';\n\nimport {\n  validateMarketingStudioImageInput,\n  validateSeedanceReferenceVideoInput,\n  validateSeedanceVideoInput,\n  validateSoulImageInput\n} from '../adapters/higgsfieldAdapter.js';\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\n\nimport type {\n  MarketingStudioImageInput,\n  SeedanceReferenceVideoInput,\n  SeedanceVideoInput,\n  SoulImageInput\n} from '../adapters/higgsfieldAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\n\nconst eventCategory = 'higgsfield';\nconst HIGGSFIELD_ORIGIN = 'https://api.higgsfield.ai';\nconst SOUL_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/higgsfield-ai/soul/v2/standard`;\nconst SEEDANCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/image-to-video`;\nconst SEEDANCE_REFERENCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/reference-to-video`;\nconst MARKETING_STUDIO_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/marketing-studio/image`;\n\nexport interface HiggsfieldRequestResult {\n  cancelUrl?: string;\n  requestId: string;\n  statusUrl: string;\n}\n\nexport interface HiggsfieldStatusResult {\n  error?: string;\n  mediaUrl?: string;\n  mediaUrls?: string[];\n  requestId: string;\n  status: string;\n}\n\ninterface HiggsfieldResponseBody {\n  cancel_url?: string;\n  detail?: unknown;\n  error?: string;\n  images?: {url?: string}[];\n  request_id?: string;\n  status?: string;\n  status_url?: string;\n  video?: {url?: string};\n}\n\n/** Never send API credentials to a provider-supplied third-party polling/cancel URL. */\nconst validateHiggsfieldUrl = (value: string, requestId: string, action: 'status' | 'cancel'): string => {\n  const url = new URL(value);\n\n  if(url.origin !== HIGGSFIELD_ORIGIN || url.username || url.password ||\n    url.pathname !== `/requests/${requestId}/${action}` || url.search || url.hash) {\n    throw new Error(`Higgsfield returned an invalid ${action} URL. Reconcile the request manually.`);\n  }\n\n  return url.href;\n};\n\nconst authHeaders = (): Headers => {\n  const keyId = Config.get<string>('higgsfield.keyId');\n  const keySecret = Config.get<string>('higgsfield.keySecret');\n\n  if(!keyId || !keySecret) {\n    throw new Error('Higgsfield is not configured. Set HIGGSFIELD_KEY_ID and HIGGSFIELD_KEY_SECRET.');\n  }\n\n  return new Headers({\n    Authorization: `Key ${keyId}:${keySecret}`,\n    'Content-Type': 'application/json'\n  });\n};\n\nconst withWebhook = (endpoint: string, webhookUrl?: string): string =>\n  (webhookUrl ? `${endpoint}?hf_webhook=${encodeURIComponent(webhookUrl)}` : endpoint);\n\nconst submit = async (\n  context: ApiContext, action: string, endpoint: string, body: Record<string, unknown>\n): Promise<HiggsfieldRequestResult> => {\n  try {\n    const data = await post(endpoint, body, {cache: false, headers: authHeaders()}) as HiggsfieldResponseBody;\n\n    if(!data.request_id || !data.status_url) {\n      throw new Error('Higgsfield submission outcome is unknown: missing request_id or status_url.');\n    }\n\n    return {\n      cancelUrl: data.cancel_url ? validateHiggsfieldUrl(data.cancel_url, data.request_id, 'cancel') : undefined,\n      requestId: data.request_id,\n      statusUrl: validateHiggsfieldUrl(data.status_url, data.request_id, 'status')\n    };\n  } catch(error) {\n    return logError(\n      {action, category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\nexport const generateSoulImage = (\n  context: ApiContext, input: SoulImageInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSoulImageInput(input);\n\n  return submit(context, 'generateSoulImage', withWebhook(SOUL_IMAGE_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    batch_size: validated.batchSize,\n    enhance_prompt: validated.enhancePrompt,\n    prompt: validated.prompt,\n    resolution: validated.resolution,\n    seed: validated.seed,\n    style_id: validated.styleId\n  });\n};\n\nexport const generateSeedanceVideo = (\n  context: ApiContext, input: SeedanceVideoInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSeedanceVideoInput(input);\n\n  return submit(context, 'generateSeedanceVideo', withWebhook(SEEDANCE_VIDEO_ENDPOINT, webhookUrl), {\n    duration: validated.duration,\n    end_image_url: validated.endImageUrl,\n    generate_audio: validated.generateAudio,\n    image_url: validated.imageUrl,\n    output_format: validated.outputFormat,\n    prompt: validated.prompt,\n    resolution: validated.resolution\n  });\n};\n\nexport const generateSeedanceReferenceVideo = (\n  context: ApiContext, input: SeedanceReferenceVideoInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSeedanceReferenceVideoInput(input);\n\n  return submit(context, 'generateSeedanceReferenceVideo', withWebhook(SEEDANCE_REFERENCE_VIDEO_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    audio_urls: validated.audioUrls,\n    duration: validated.duration,\n    generate_audio: validated.generateAudio,\n    image_urls: validated.imageUrls,\n    output_format: validated.outputFormat,\n    prompt: validated.prompt,\n    resolution: validated.resolution,\n    video_urls: validated.videoUrls\n  });\n};\n\nexport const generateMarketingStudioImage = (\n  context: ApiContext, input: MarketingStudioImageInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateMarketingStudioImageInput(input);\n\n  return submit(context, 'generateMarketingStudioImage', withWebhook(MARKETING_STUDIO_IMAGE_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    enhance_prompt: validated.enhancePrompt,\n    image_urls: validated.imageUrls,\n    preset_id: validated.presetId,\n    prompt: validated.prompt,\n    quality: validated.quality,\n    resolution: validated.resolution\n  });\n};\n\nexport const getHiggsfieldRequestStatus = async (\n  context: ApiContext, requestId: string\n): Promise<HiggsfieldStatusResult> => {\n  try {\n    const statusUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/status`, requestId, 'status');\n    const data = await get(statusUrl, {}, {cache: false, headers: authHeaders()}) as HiggsfieldResponseBody;\n\n    if(data.request_id !== requestId) {\n      throw new Error('Higgsfield status response returned an unexpected request identifier.');\n    }\n\n    return {\n      error: data.error,\n      mediaUrl: data.video?.url || data.images?.[0]?.url,\n      mediaUrls: data.images?.map((image) => image.url).filter((url): url is string => Boolean(url)),\n      requestId,\n      status: data.status || 'unknown'\n    };\n  } catch(error) {\n    return logError(\n      {action: 'getHiggsfieldRequestStatus', category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\nexport const cancelHiggsfieldRequest = async (context: ApiContext, requestId: string): Promise<boolean> => {\n  try {\n    const cancelUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/cancel`, requestId, 'cancel');\n    await post(cancelUrl, {}, {cache: false, headers: authHeaders()});\n\n    return (await getHiggsfieldRequestStatus(context, requestId)).status === 'canceled';\n  } catch(error) {\n    return logError(\n      {action: 'cancelHiggsfieldRequest', category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n"],"names":["get","post","validateMarketingStudioImageInput","validateSeedanceReferenceVideoInput","validateSeedanceVideoInput","validateSoulImageInput","Config","ErrorTypes","logError","eventCategory","HIGGSFIELD_ORIGIN","SOUL_IMAGE_ENDPOINT","SEEDANCE_VIDEO_ENDPOINT","SEEDANCE_REFERENCE_VIDEO_ENDPOINT","MARKETING_STUDIO_IMAGE_ENDPOINT","validateHiggsfieldUrl","value","requestId","action","url","URL","origin","username","password","pathname","search","hash","Error","href","authHeaders","keyId","keySecret","Headers","Authorization","withWebhook","endpoint","webhookUrl","encodeURIComponent","submit","context","body","data","cache","headers","request_id","status_url","cancelUrl","cancel_url","undefined","statusUrl","error","category","EXTERNAL_API_ERROR","generateSoulImage","input","validated","aspect_ratio","aspectRatio","batch_size","batchSize","enhance_prompt","enhancePrompt","prompt","resolution","seed","style_id","styleId","generateSeedanceVideo","duration","end_image_url","endImageUrl","generate_audio","generateAudio","image_url","imageUrl","output_format","outputFormat","generateSeedanceReferenceVideo","audio_urls","audioUrls","image_urls","imageUrls","video_urls","videoUrls","generateMarketingStudioImage","preset_id","presetId","quality","getHiggsfieldRequestStatus","mediaUrl","video","images","mediaUrls","map","image","filter","Boolean","status","cancelHiggsfieldRequest"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/higgsfield.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\n */\nimport {get, post} from '@nlabs/rip-hunter';\n\nimport {\n  validateMarketingStudioImageInput,\n  validateSeedanceReferenceVideoInput,\n  validateSeedanceVideoInput,\n  validateSoulImageInput\n} from '../adapters/higgsfieldAdapter.js';\nimport {getHiggsfieldModel} from '../adapters/higgsfieldModelCatalog.js';\nimport {validateHiggsfieldModelInput} from '../adapters/higgsfieldModels.js';\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\n\nimport type {\n  MarketingStudioImageInput,\n  SeedanceReferenceVideoInput,\n  SeedanceVideoInput,\n  SoulImageInput\n} from '../adapters/higgsfieldAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\n\nconst eventCategory = 'higgsfield';\nconst HIGGSFIELD_ORIGIN = 'https://api.higgsfield.ai';\nconst SOUL_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/higgsfield-ai/soul/v2/standard`;\nconst SEEDANCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/image-to-video`;\nconst SEEDANCE_REFERENCE_VIDEO_ENDPOINT = `${HIGGSFIELD_ORIGIN}/bytedance/seedance-2.5/reference-to-video`;\nconst MARKETING_STUDIO_IMAGE_ENDPOINT = `${HIGGSFIELD_ORIGIN}/marketing-studio/image`;\n\nexport interface HiggsfieldRequestResult {\n  cancelUrl?: string;\n  requestId: string;\n  statusUrl: string;\n}\n\nexport interface HiggsfieldStatusResult {\n  error?: string;\n  mediaUrl?: string;\n  mediaUrls?: string[];\n  requestId: string;\n  status: string;\n}\n\ninterface HiggsfieldResponseBody {\n  cancel_url?: string;\n  detail?: unknown;\n  error?: string;\n  images?: {url?: string}[];\n  request_id?: string;\n  status?: string;\n  status_url?: string;\n  video?: {url?: string};\n}\n\n/** Never send API credentials to a provider-supplied third-party polling/cancel URL. */\nconst validateHiggsfieldUrl = (value: string, requestId: string, action: 'status' | 'cancel'): string => {\n  const url = new URL(value);\n\n  if(url.origin !== HIGGSFIELD_ORIGIN || url.username || url.password ||\n    url.pathname !== `/requests/${requestId}/${action}` || url.search || url.hash) {\n    throw new Error(`Higgsfield returned an invalid ${action} URL. Reconcile the request manually.`);\n  }\n\n  return url.href;\n};\n\nconst authHeaders = (): Headers => {\n  const keyId = Config.get<string>('higgsfield.keyId');\n  const keySecret = Config.get<string>('higgsfield.keySecret');\n\n  if(!keyId || !keySecret) {\n    throw new Error('Higgsfield is not configured. Set HIGGSFIELD_KEY_ID and HIGGSFIELD_KEY_SECRET.');\n  }\n\n  return new Headers({\n    Authorization: `Key ${keyId}:${keySecret}`,\n    'Content-Type': 'application/json'\n  });\n};\n\nconst withWebhook = (endpoint: string, webhookUrl?: string): string =>\n  (webhookUrl ? `${endpoint}?hf_webhook=${encodeURIComponent(webhookUrl)}` : endpoint);\n\nconst submit = async (\n  context: ApiContext, action: string, endpoint: string, body: Record<string, unknown>\n): Promise<HiggsfieldRequestResult> => {\n  try {\n    const data = await post(endpoint, body, {cache: false, headers: authHeaders()}) as HiggsfieldResponseBody;\n\n    if(!data.request_id || !data.status_url) {\n      throw new Error('Higgsfield submission outcome is unknown: missing request_id or status_url.');\n    }\n\n    return {\n      cancelUrl: data.cancel_url ? validateHiggsfieldUrl(data.cancel_url, data.request_id, 'cancel') : undefined,\n      requestId: data.request_id,\n      statusUrl: validateHiggsfieldUrl(data.status_url, data.request_id, 'status')\n    };\n  } catch(error) {\n    return logError(\n      {action, category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\nexport const generateSoulImage = (\n  context: ApiContext, input: SoulImageInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSoulImageInput(input);\n\n  return submit(context, 'generateSoulImage', withWebhook(SOUL_IMAGE_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    batch_size: validated.batchSize,\n    enhance_prompt: validated.enhancePrompt,\n    prompt: validated.prompt,\n    resolution: validated.resolution,\n    seed: validated.seed,\n    style_id: validated.styleId\n  });\n};\n\nexport const generateSeedanceVideo = (\n  context: ApiContext, input: SeedanceVideoInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSeedanceVideoInput(input);\n\n  return submit(context, 'generateSeedanceVideo', withWebhook(SEEDANCE_VIDEO_ENDPOINT, webhookUrl), {\n    duration: validated.duration,\n    end_image_url: validated.endImageUrl,\n    generate_audio: validated.generateAudio,\n    image_url: validated.imageUrl,\n    output_format: validated.outputFormat,\n    prompt: validated.prompt,\n    resolution: validated.resolution\n  });\n};\n\nexport const generateSeedanceReferenceVideo = (\n  context: ApiContext, input: SeedanceReferenceVideoInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateSeedanceReferenceVideoInput(input);\n\n  return submit(context, 'generateSeedanceReferenceVideo', withWebhook(SEEDANCE_REFERENCE_VIDEO_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    audio_urls: validated.audioUrls,\n    duration: validated.duration,\n    generate_audio: validated.generateAudio,\n    image_urls: validated.imageUrls,\n    output_format: validated.outputFormat,\n    prompt: validated.prompt,\n    resolution: validated.resolution,\n    video_urls: validated.videoUrls\n  });\n};\n\nexport const generateMarketingStudioImage = (\n  context: ApiContext, input: MarketingStudioImageInput, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const validated = validateMarketingStudioImageInput(input);\n\n  return submit(context, 'generateMarketingStudioImage', withWebhook(MARKETING_STUDIO_IMAGE_ENDPOINT, webhookUrl), {\n    aspect_ratio: validated.aspectRatio,\n    enhance_prompt: validated.enhancePrompt,\n    image_urls: validated.imageUrls,\n    preset_id: validated.presetId,\n    prompt: validated.prompt,\n    quality: validated.quality,\n    resolution: validated.resolution\n  });\n};\n\nexport const getHiggsfieldRequestStatus = async (\n  context: ApiContext, requestId: string\n): Promise<HiggsfieldStatusResult> => {\n  try {\n    const statusUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/status`, requestId, 'status');\n    const data = await get(statusUrl, {}, {cache: false, headers: authHeaders()}) as HiggsfieldResponseBody;\n\n    if(data.request_id !== requestId) {\n      throw new Error('Higgsfield status response returned an unexpected request identifier.');\n    }\n\n    return {\n      error: data.error,\n      mediaUrl: data.video?.url || data.images?.[0]?.url,\n      mediaUrls: data.images?.map((image) => image.url).filter((url): url is string => Boolean(url)),\n      requestId,\n      status: data.status || 'unknown'\n    };\n  } catch(error) {\n    return logError(\n      {action: 'getHiggsfieldRequestStatus', category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\nexport const cancelHiggsfieldRequest = async (context: ApiContext, requestId: string): Promise<boolean> => {\n  try {\n    const cancelUrl = validateHiggsfieldUrl(`${HIGGSFIELD_ORIGIN}/requests/${requestId}/cancel`, requestId, 'cancel');\n    await post(cancelUrl, {}, {cache: false, headers: authHeaders()});\n\n    return (await getHiggsfieldRequestStatus(context, requestId)).status === 'canceled';\n  } catch(error) {\n    return logError(\n      {action: 'cancelHiggsfieldRequest', category: eventCategory, value: ErrorTypes.EXTERNAL_API_ERROR}, error as Error, context\n    ) as Promise<never>;\n  }\n};\n\n/** Submit one allowlisted catalog model; never retry a submission with an unknown outcome. */\nexport const generateHiggsfieldModel = (\n  context: ApiContext, modelId: string, input: Record<string, unknown>, webhookUrl?: string\n): Promise<HiggsfieldRequestResult> => {\n  const model = getHiggsfieldModel(modelId);\n  return submit(context, 'generateHiggsfieldModel', withWebhook(`${HIGGSFIELD_ORIGIN}/${model.id}`, webhookUrl),\n    validateHiggsfieldModelInput(modelId, input));\n};\n"],"names":["get","post","validateMarketingStudioImageInput","validateSeedanceReferenceVideoInput","validateSeedanceVideoInput","validateSoulImageInput","getHiggsfieldModel","validateHiggsfieldModelInput","Config","ErrorTypes","logError","eventCategory","HIGGSFIELD_ORIGIN","SOUL_IMAGE_ENDPOINT","SEEDANCE_VIDEO_ENDPOINT","SEEDANCE_REFERENCE_VIDEO_ENDPOINT","MARKETING_STUDIO_IMAGE_ENDPOINT","validateHiggsfieldUrl","value","requestId","action","url","URL","origin","username","password","pathname","search","hash","Error","href","authHeaders","keyId","keySecret","Headers","Authorization","withWebhook","endpoint","webhookUrl","encodeURIComponent","submit","context","body","data","cache","headers","request_id","status_url","cancelUrl","cancel_url","undefined","statusUrl","error","category","EXTERNAL_API_ERROR","generateSoulImage","input","validated","aspect_ratio","aspectRatio","batch_size","batchSize","enhance_prompt","enhancePrompt","prompt","resolution","seed","style_id","styleId","generateSeedanceVideo","duration","end_image_url","endImageUrl","generate_audio","generateAudio","image_url","imageUrl","output_format","outputFormat","generateSeedanceReferenceVideo","audio_urls","audioUrls","image_urls","imageUrls","video_urls","videoUrls","generateMarketingStudioImage","preset_id","presetId","quality","getHiggsfieldRequestStatus","mediaUrl","video","images","mediaUrls","map","image","filter","Boolean","status","cancelHiggsfieldRequest","generateHiggsfieldModel","modelId","model","id"],"mappings":"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"}

package/lib/actions/imageGeneration.d.ts

@@ -5,7 +5,11 @@ import type { ApiContext } from '../types/auth.types.js';
 /** Only an explicit provider rejection proves it is safe to release a reservation. */
 export declare class ImageGenerationRejectedError extends Error {
 }
-export type GenerateImageInput = (GeminiImageInput & {
+export type GenerateImageInput = {
+    model: string;
+    modelInput: Record<string, unknown>;
+    provider: 'higgsfield';
+} | (GeminiImageInput & {
     provider: 'gemini';
 }) | (OpenAIImageInput & {
     provider: 'openai';