velocious 1.0.456 → 1.0.458

package/build/environment-handlers/node/cli/commands/generate/frontend-models.js

@@ -288,6 +288,7 @@ export default class DbGenerateFrontendModels extends BaseCommand {
     }
     const collectionCommands = modelConfig.collectionCommands
     const memberCommands = modelConfig.memberCommands
+    const commandMetadata = modelConfig.commandMetadata || {}
     const builtInCollectionCommandsAreDefault = builtInCollectionCommands.create === "create" && builtInCollectionCommands.index === "index"
     const builtInMemberCommandsAreDefault = builtInMemberCommands.attach === "attach"
       && builtInMemberCommands.destroy === "destroy"
@@ -460,35 +461,39 @@ export default class DbGenerateFrontendModels extends BaseCommand {
     }
 
     for (const methodName of Object.keys(collectionCommands)) {
+      const signature = this.customCommandMethodSignature({commandMetadata, methodName})
+
       fileContent += "\n"
       fileContent += "  /**\n"
       fileContent += `   * Runs ${methodName}.\n`
-      fileContent += "   * @param {...FrontendModelAttributeValue} commandArguments - Custom command arguments.\n"
-      fileContent += "   * @returns {Promise<Record<string, FrontendModelAttributeValue>>} - Command response.\n"
+      fileContent += signature.paramDocs
+      fileContent += `   * @returns {Promise<${signature.returnType}>} - Command response.\n`
       fileContent += "   */\n"
-      fileContent += `  static async ${methodName}(...commandArguments) {\n`
+      fileContent += `  static async ${methodName}(${signature.parameters}) {\n`
       fileContent += "    return await this.executeCustomCommand({\n"
       fileContent += `      commandName: ${JSON.stringify(collectionCommands[methodName])},\n`
       fileContent += `      commandType: ${JSON.stringify(collectionCommands[methodName])},\n`
-      fileContent += `      payload: ${className}.normalizeCustomCommandPayloadArguments(commandArguments),\n`
+      fileContent += `      payload: ${className}.normalizeCustomCommandPayloadArguments(${signature.payloadArguments}),\n`
       fileContent += "      resourcePath: this.resourcePath()\n"
       fileContent += "    })\n"
       fileContent += "  }\n"
     }
 
     for (const methodName of Object.keys(memberCommands)) {
+      const signature = this.customCommandMethodSignature({commandMetadata, methodName})
+
       fileContent += "\n"
       fileContent += "  /**\n"
       fileContent += `   * Runs ${methodName}.\n`
-      fileContent += "   * @param {...FrontendModelAttributeValue} commandArguments - Custom command arguments.\n"
-      fileContent += "   * @returns {Promise<Record<string, FrontendModelAttributeValue>>} - Command response.\n"
+      fileContent += signature.paramDocs
+      fileContent += `   * @returns {Promise<${signature.returnType}>} - Command response.\n`
       fileContent += "   */\n"
-      fileContent += `  async ${methodName}(...commandArguments) {\n`
+      fileContent += `  async ${methodName}(${signature.parameters}) {\n`
       fileContent += `    return await ${className}.executeCustomCommand({\n`
       fileContent += `      commandName: ${JSON.stringify(memberCommands[methodName])},\n`
       fileContent += `      commandType: ${JSON.stringify(memberCommands[methodName])},\n`
       fileContent += "      memberId: this.primaryKeyValue(),\n"
-      fileContent += `      payload: ${className}.normalizeCustomCommandPayloadArguments(commandArguments),\n`
+      fileContent += `      payload: ${className}.normalizeCustomCommandPayloadArguments(${signature.payloadArguments}),\n`
       fileContent += `      resourcePath: ${className}.resourcePath()\n`
       fileContent += "    })\n"
       fileContent += "  }\n"
@@ -1327,7 +1332,69 @@ export default class DbGenerateFrontendModels extends BaseCommand {
       sourceClassName: ownerClassName
     })
 
-    return jsDocType ? {jsDocType} : null
+    // Frontend attributes hold the serialized (resolved) value, so an async
+    // backend accessor typed `Promise<number>` must surface as `number` — the
+    // same unwrapping the resource-method inference path applies.
+    return jsDocType
+      ? {jsDocType: this.frontendResolvableAttributeJsDocType(this.unwrappedPromiseJsDocType({jsDocType}))}
+      : null
+  }
+
+  /**
+   * A backend accessor's `@returns` can reference types that exist only on the
+   * backend (e.g. a model-local `@typedef AgentRunPlanningArtifact`). The frontend
+   * model can't resolve those, so fall back to `any` rather than emitting an
+   * undefined type name. Types built only from primitives and known generic
+   * builtins pass through unchanged.
+   * @param {string} jsDocType - Resolved (Promise-unwrapped) attribute type.
+   * @returns {string} - A frontend-resolvable attribute type.
+   */
+  frontendResolvableAttributeJsDocType(jsDocType) {
+    const safeTypeIdentifiers = new Set([
+      "Array", "Date", "Exclude", "Extract", "FrontendModelAttributeValue", "FrontendModelTransportValue",
+      "Map", "NonNullable", "Omit", "Partial", "Pick", "Promise", "Readonly", "ReadonlyArray", "Record",
+      "Required", "ReturnType", "Set"
+    ])
+    const referencedIdentifiers = jsDocType.match(/[A-Z][A-Za-z0-9_$]*/g) || []
+
+    if (referencedIdentifiers.some((identifier) => !safeTypeIdentifiers.has(identifier))) {
+      return "any"
+    }
+
+    return jsDocType
+  }
+
+  /**
+   * Builds the JSDoc param block, parameter list, payload-argument expression, and
+   * return type for a custom command method. With declared `args` each becomes a
+   * named, typed parameter mapped positionally into the command payload; without
+   * them the method stays variadic.
+   * @param {object} args - Arguments.
+   * @param {Record<string, {args: Array<{name: string, type: string}>, returnType: string | null}>} args.commandMetadata - Per-command metadata.
+   * @param {string} args.methodName - Command method name.
+   * @returns {{paramDocs: string, parameters: string, payloadArguments: string, returnType: string}} - Generation pieces.
+   */
+  customCommandMethodSignature({commandMetadata, methodName}) {
+    const metadata = commandMetadata[methodName] || {args: [], returnType: null}
+    const returnType = metadata.returnType || "Record<string, ?>"
+
+    if (metadata.args.length > 0) {
+      const parameterNames = metadata.args.map((arg) => arg.name)
+
+      return {
+        paramDocs: metadata.args.map((arg) => `   * @param {${arg.type}} ${arg.name} - Command argument.\n`).join(""),
+        parameters: parameterNames.join(", "),
+        payloadArguments: `[${parameterNames.join(", ")}]`,
+        returnType
+      }
+    }
+
+    return {
+      paramDocs: "   * @param {...FrontendModelAttributeValue} commandArguments - Custom command arguments.\n",
+      parameters: "...commandArguments",
+      payloadArguments: "commandArguments",
+      returnType
+    }
   }
 
   /**

package/build/frontend-model-controller.js

@@ -10,7 +10,9 @@ import {normalizeGroup as normalizeQueryGroup, normalizeJoins as normalizeQueryJ
 import {assignSafeProperty, deserializeFrontendModelTransportValue, isBackendModelInstance, serializeFrontendModelTransportValue} from "./frontend-models/transport-serialization.js"
 import RoutesResolver from "./routes/resolver.js"
 import {ValidationError} from "./database/record/index.js"
+import { normalizeDateStringForWrite } from "./database/datetime-storage.js"
 import VelociousError from "./velocious-error.js"
+import isDate from "./utils/is-date.js"
 import isPlainObject from "./utils/plain-object.js"
 
 /**
@@ -2212,9 +2214,9 @@ export default class FrontendModelController extends Controller {
       const isDateTimeColumn = typeof columnType === "string" && ["date", "datetime", "timestamp"].some((type) => columnType.includes(type))
 
       if (isDateTimeColumn) {
-        const parsedDate = new Date(value)
+        const parsedDate = normalizeDateStringForWrite(value)
 
-        if (!Number.isNaN(parsedDate.getTime())) {
+        if (isDate(parsedDate)) {
           return parsedDate
         }
       }

package/build/frontend-models/base.js

@@ -5,6 +5,7 @@ import timeout from "awaitery/build/timeout.js"
 import wait from "awaitery/build/wait.js"
 import FrontendModelQuery, {frontendModelEventOptionsPayload} from "./query.js"
 import FrontendModelPreloader from "./preloader.js"
+import { normalizeDateStringForWrite } from "../database/datetime-storage.js"
 import {registerFrontendModel, resolveFrontendModelClass} from "./model-registry.js"
 import {validateFrontendModelResourceCommandName, validateFrontendModelResourcePath} from "./resource-config-validation.js"
 import {deserializeFrontendModelTransportValue, serializeFrontendModelTransportValue} from "./transport-serialization.js"
@@ -65,9 +66,19 @@ import {readPayloadAssociationCount, readPayloadComputedAbility, readPayloadQuer
  */
 /**
  * Frontend model static side.
- * @template {FrontendModelBase} [T=FrontendModelBase]
- * @template {Record<string, FrontendModelAttributeValue>} [Attributes=Record<string, FrontendModelAttributeValue>]
- * @template {Record<string, FrontendModelAttributeValue>} [CreateAttributes=Record<string, FrontendModelAttributeValue>]
+ *
+ * The template defaults are intentionally permissive (`any` model/attribute
+ * params). The bare `FrontendModelClass` is the `@this`/constraint type on the
+ * static query methods (findBy/find/where/preload/...); a generated subclass
+ * declares typed-attribute generics (e.g. `FrontendModelBase<AccountAttributes,
+ * AccountCreateAttributes, AccountUpdateAttributes>`) which, against a concrete
+ * `Record<string, FrontendModelTransportValue>` default, fail the constraint by
+ * invariance. Defaulting to `any` lets any subclass satisfy the constraint while
+ * the methods' own `@template T` still captures the precise calling class for
+ * their return types.
+ * @template {FrontendModelBase} [T=FrontendModelBase<any, any, any>]
+ * @template {object} [Attributes=any]
+ * @template {object} [CreateAttributes=any]
  * @typedef {{new (): T, create(attributes?: CreateAttributes): Promise<T>} & Omit<typeof FrontendModelBase, "create" | "prototype">} FrontendModelClass
  */
 /**
@@ -79,7 +90,7 @@ import {readPayloadAssociationCount, readPayloadComputedAbility, readPayloadQuer
  * Loaded instance type for relationship helper generics. Older generated
  * frontend models passed model classes into relationship helpers, while newer
  * generated models pass instance types.
- * @template {FrontendModelBase | typeof FrontendModelBase} T
+ * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} T
  * @typedef {T extends new (...args: any[]) => infer Instance ? Instance : T} FrontendModelRelationshipModel
  */
 /**
@@ -280,9 +291,9 @@ export class AttributeNotSelectedError extends Error {
 
 /**
  * Lightweight singular relationship state holder for frontend model instances.
- * @template {FrontendModelBase | typeof FrontendModelBase} S
- * @template {FrontendModelBase | typeof FrontendModelBase} T
- * @template {Record<string, FrontendModelAttributeValue>} [TargetCreateAttributes=Record<string, FrontendModelAttributeValue>]
+ * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} S
+ * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} T
+ * @template {object} [TargetCreateAttributes=Record<string, FrontendModelAttributeValue>]
  */
 export class FrontendModelSingularRelationship {
   /**
@@ -400,9 +411,9 @@ export class FrontendModelSingularRelationship {
 
 /**
  * Lightweight has-many relationship state holder for frontend model instances.
- * @template {FrontendModelBase | typeof FrontendModelBase} S
- * @template {FrontendModelBase | typeof FrontendModelBase} T
- * @template {Record<string, FrontendModelAttributeValue>} [TargetCreateAttributes=Record<string, FrontendModelAttributeValue>]
+ * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} S
+ * @template {FrontendModelBase<any, any, any> | typeof FrontendModelBase} T
+ * @template {object} [TargetCreateAttributes=Record<string, FrontendModelAttributeValue>]
  */
 export class FrontendModelHasManyRelationship {
   /**
@@ -539,8 +550,13 @@ export class FrontendModelHasManyRelationship {
 }
 
 /**
- * Frontend model relationship helper type.
- * @typedef {FrontendModelHasManyRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>> | FrontendModelSingularRelationship<FrontendModelBase, FrontendModelBase, Record<string, FrontendModelAttributeValue>>} FrontendModelRelationship
+ * Frontend model relationship helper type. Returned by `getRelationshipByName`,
+ * which generated models immediately cast to their concrete relationship type
+ * (e.g. `FrontendModelSingularRelationship<Owner, Target, TargetCreateAttributes>`).
+ * The members use `any` type args so that cast is allowed regardless of the
+ * target model's typed-attribute generics — a concrete `FrontendModelBase` member
+ * here makes the cast a non-overlapping (TS2352) error for every typed model.
+ * @typedef {FrontendModelHasManyRelationship<any, any, any> | FrontendModelSingularRelationship<any, any, any>} FrontendModelRelationship
  */
 
 /**
@@ -1882,9 +1898,16 @@ function assertDefinedFindByConditionValue(value, keyPath) {
 
 /**
  * Base frontend model.
- * @template {Record<string, FrontendModelAttributeValue>} [Attributes=Record<string, FrontendModelAttributeValue>]
- * @template {Record<string, FrontendModelAttributeValue>} [CreateAttributes=Record<string, FrontendModelAttributeValue>]
- * @template {Record<string, FrontendModelAttributeValue>} [UpdateAttributes=Record<string, FrontendModelAttributeValue>]
+ *
+ * Defaults are `any` so the bare `FrontendModelBase` — used throughout as a
+ * constraint/parameter type for "any frontend model" — accepts generated
+ * subclasses declaring typed-attribute generics (`FrontendModelBase<XAttributes,
+ * ...>`). A concrete `Record<string, FrontendModelAttributeValue>` default makes
+ * those subclasses fail by invariance. Subclasses still pass their precise
+ * attribute typedefs, so typed accessors keep their precision.
+ * @template {object} [Attributes=any]
+ * @template {object} [CreateAttributes=any]
+ * @template {object} [UpdateAttributes=any]
  */
 export default class FrontendModelBase {
   /**
@@ -3775,6 +3798,12 @@ export default class FrontendModelBase {
    */
   static findByPrimitiveValuesMatch(actualValue, expectedValue) {
     if (actualValue instanceof Date && typeof expectedValue === "string") {
+      const normalizedExpectedValue = normalizeDateStringForWrite(expectedValue)
+
+      if (normalizedExpectedValue instanceof Date) {
+        return actualValue.toISOString() === normalizedExpectedValue.toISOString()
+      }
+
       return actualValue.toISOString() === expectedValue
     }
 

package/build/frontend-models/resource-definition.js

@@ -90,6 +90,10 @@ function normalizeFrontendModelResourceConfiguration(resourceConfiguration) {
     builtInCollectionCommands: normalizedCommands.builtInCollectionCommands,
     builtInMemberCommands: normalizedCommands.builtInMemberCommands,
     collectionCommands: normalizedCommands.collectionCommands,
+    // Per-command metadata (typed args + declared return type) keyed by method
+    // name, derived from `{name, args?, returnType?}` command entries. The
+    // generator uses it to type each custom command method.
+    commandMetadata: normalizedCommands.commandMetadata,
     memberCommands: normalizedCommands.memberCommands
   }
 }
@@ -151,7 +155,7 @@ function defaultCrudAbilities() {
 /**
  * Runs normalize frontend model resource commands.
  * @param {import("../configuration-types.js").FrontendModelResourceConfiguration} resourceConfiguration - Raw resource configuration.
- * @returns {{builtInCollectionCommands: Record<string, string>, builtInMemberCommands: Record<string, string>, collectionCommands: Record<string, string>, memberCommands: Record<string, string>}} - Normalized command configuration.
+ * @returns {{builtInCollectionCommands: Record<string, string>, builtInMemberCommands: Record<string, string>, collectionCommands: Record<string, string>, commandMetadata: Record<string, {args: Array<{name: string, type: string}>, returnType: string | null}>, memberCommands: Record<string, string>}} - Normalized command configuration.
  */
 function normalizeFrontendModelResourceCommands(resourceConfiguration) {
   const builtInCollectionCommands = resourceConfiguration.builtInCollectionCommands
@@ -180,11 +184,15 @@ function normalizeFrontendModelResourceCommands(resourceConfiguration) {
     modelName: "MemberCommand"
   })
 
+  const normalizedCollectionCommands = normalizeFrontendModelCustomCommands({commandsConfig: customCollectionCommands, modelName: "CollectionCommand"})
+  const normalizedMemberCommands = normalizeFrontendModelCustomCommands({commandsConfig: customMemberCommands, modelName: "MemberCommand"})
+
   return {
     builtInCollectionCommands: normalizedBuiltInCollectionCommands,
     builtInMemberCommands: normalizedBuiltInMemberCommands,
-    collectionCommands: normalizeFrontendModelCustomCommands({commandsConfig: customCollectionCommands, modelName: "CollectionCommand"}),
-    memberCommands: normalizeFrontendModelCustomCommands({commandsConfig: customMemberCommands, modelName: "MemberCommand"})
+    collectionCommands: normalizedCollectionCommands.commands,
+    commandMetadata: {...normalizedCollectionCommands.metadata, ...normalizedMemberCommands.metadata},
+    memberCommands: normalizedMemberCommands.commands
   }
 }
 
@@ -228,27 +236,30 @@ function normalizeFrontendModelBuiltInCommands({commandDefaults, commandsConfig,
 }
 
 /**
- * Runs normalize frontend model custom commands.
+ * Runs normalize frontend model custom commands. Entries are either a plain
+ * camelCase method-name string or a `{name, args?, returnType?}` object that
+ * also declares the command's typed arguments and/or response type.
  * @param {object} args - Arguments.
- * @param {string[] | undefined} args.commandsConfig - Custom commands config (camelCase method-name list).
+ * @param {Array<string | {name: string, args?: Array<{name: string, type: string}>, returnType?: string}> | undefined} args.commandsConfig - Custom commands config.
  * @param {string} args.modelName - Diagnostic model name.
- * @returns {Record<string, string>} - Normalized custom command config (camelCase method name → kebab-case command slug).
+ * @returns {{commands: Record<string, string>, metadata: Record<string, {args: Array<{name: string, type: string}>, returnType: string | null}>}} - Route map (method name → kebab slug) + per-command metadata.
  */
 function normalizeFrontendModelCustomCommands({commandsConfig, modelName}) {
   if (!commandsConfig) {
-    return {}
+    return {commands: {}, metadata: {}}
   }
 
   if (!Array.isArray(commandsConfig)) {
     throw new Error(`${modelName} configuration must use the array form. Object form is no longer supported.`)
   }
 
-  /**
-   * Normalized commands.
-   * @type {Record<string, string>} */
-  const normalizedCommands = {}
+  /** @type {Record<string, string>} */
+  const commands = {}
+  /** @type {Record<string, {args: Array<{name: string, type: string}>, returnType: string | null}>} */
+  const metadata = {}
 
-  for (const methodName of commandsConfig) {
+  for (const commandEntry of commandsConfig) {
+    const {methodName, args, returnType} = normalizeFrontendModelCustomCommandEntry({commandEntry, modelName})
     const validatedMethodName = validateFrontendModelResourceCommandName({
       commandName: methodName,
       commandType: methodName,
@@ -256,10 +267,90 @@ function normalizeFrontendModelCustomCommands({commandsConfig, modelName}) {
     })
     const commandSlug = inflection.dasherize(inflection.underscore(validatedMethodName))
 
-    normalizedCommands[validatedMethodName] = commandSlug
+    commands[validatedMethodName] = commandSlug
+    metadata[validatedMethodName] = {args, returnType}
   }
 
-  return normalizedCommands
+  return {commands, metadata}
+}
+
+/**
+ * Normalizes one custom-command entry (string shorthand or contract object).
+ * @param {object} args - Arguments.
+ * @param {unknown} args.commandEntry - Raw command entry.
+ * @param {string} args.modelName - Diagnostic model name.
+ * @returns {{methodName: string, args: Array<{name: string, type: string}>, returnType: string | null}} - Method name + metadata.
+ */
+function normalizeFrontendModelCustomCommandEntry({commandEntry, modelName}) {
+  if (typeof commandEntry === "string") {
+    return {methodName: commandEntry, args: [], returnType: null}
+  }
+
+  if (!commandEntry || typeof commandEntry !== "object" || Array.isArray(commandEntry)) {
+    throw new Error(`${modelName} entries must be a camelCase name string or a {name, args?, returnType?} object`)
+  }
+
+  const {name, args, returnType, ...rest} = /** @type {{name?: unknown, args?: unknown, returnType?: unknown}} */ (commandEntry)
+
+  if (Object.keys(rest).length > 0) {
+    throw new Error(`Unexpected ${modelName} keys: ${Object.keys(rest).join(", ")}. Allowed: name, args, returnType`)
+  }
+
+  if (typeof name !== "string" || name.length < 1) {
+    throw new Error(`${modelName} object entries require a non-empty 'name' string`)
+  }
+
+  return {
+    methodName: name,
+    args: normalizeFrontendModelCommandArgs({args, commandName: name, modelName}),
+    returnType: normalizeFrontendModelCommandReturnType({commandName: name, modelName, returnType})
+  }
+}
+
+/**
+ * Validates and normalizes a custom command's typed-argument list.
+ * @param {object} args - Arguments.
+ * @param {unknown} args.args - Raw command args.
+ * @param {string} args.commandName - Command name for diagnostics.
+ * @param {string} args.modelName - Diagnostic model name.
+ * @returns {Array<{name: string, type: string}>} - Normalized typed command arguments.
+ */
+function normalizeFrontendModelCommandArgs({args, commandName, modelName}) {
+  if (args === undefined || args === null) {
+    return []
+  }
+
+  if (!Array.isArray(args)) {
+    throw new Error(`${modelName} '${commandName}' args must be an array of {name, type} objects`)
+  }
+
+  return args.map((arg) => {
+    if (!arg || typeof arg !== "object" || typeof arg.name !== "string" || arg.name.length < 1 || typeof arg.type !== "string" || arg.type.trim().length < 1) {
+      throw new Error(`${modelName} '${commandName}' args entries require non-empty 'name' and JSDoc-type 'type' strings`)
+    }
+
+    return {name: arg.name, type: arg.type.trim()}
+  })
+}
+
+/**
+ * Validates and normalizes a custom command's declared JSDoc return type.
+ * @param {object} args - Arguments.
+ * @param {string} args.commandName - Command name for diagnostics.
+ * @param {string} args.modelName - Diagnostic model name.
+ * @param {unknown} args.returnType - Raw return type.
+ * @returns {string | null} - Normalized JSDoc return type.
+ */
+function normalizeFrontendModelCommandReturnType({commandName, modelName, returnType}) {
+  if (returnType === undefined || returnType === null) {
+    return null
+  }
+
+  if (typeof returnType !== "string" || returnType.trim().length < 1) {
+    throw new Error(`${modelName} '${commandName}' returnType must be a non-empty JSDoc type string`)
+  }
+
+  return returnType.trim()
 }
 
 /**

package/build/src/cli/commands/db/drop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/db/drop.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CA0CzC;IAED;;;;OAIG;IACH,yCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAOzB;CACF;0BA1EyB,mBAAmB"}
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/db/drop.js"],"names":[],"mappings":"AAIA;IACE;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CA8CzC;IAED;;;;OAIG;IACH,yCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAOzB;CACF;0BA9EyB,mBAAmB"}

package/build/src/cli/commands/db/drop.js

@@ -26,9 +26,15 @@ export default class DbDrop extends DbBaseCommand {
                 // driver's system default.
                 const configuredFallback = newConfiguration.useDatabase;
                 const useConfiguredFallback = typeof configuredFallback == "string" && configuredFallback.length > 0 && configuredFallback != targetDatabaseName;
-                newConfiguration.database = useConfiguredFallback
-                    ? configuredFallback
-                    : this.systemFallbackDatabaseName(databaseType);
+                if (useConfiguredFallback) {
+                    newConfiguration.database = configuredFallback;
+                }
+                else if (databaseType == "mysql") {
+                    delete newConfiguration.database;
+                }
+                else {
+                    newConfiguration.database = this.systemFallbackDatabaseName(databaseType);
+                }
                 if (databaseType == "mssql" && newConfiguration.sqlConfig?.database) {
                     delete newConfiguration.sqlConfig.database;
                 }
@@ -63,4 +69,4 @@ export default class DbDrop extends DbBaseCommand {
         await this.queryOrCollectSqls(sqls, (sql) => ({ databaseName, sql }));
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/configuration-types.d.ts

@@ -264,20 +264,34 @@
  * @property {string[]} [abilities] - Ability action list (camelCase action names). Defaults to `["read"]` for `find` and `index` when omitted.
  * @property {Record<string, FrontendModelAttachmentConfiguration>} [attachments] - Attachment helpers keyed by attachment name.
  * @property {string[]} [commands] - Legacy built-in command names (`index`, `find`, `create`, `update`, `destroy`, `attach`, `download`, `url`).
- * @property {string[]} [collectionCommands] - Custom collection commands as camelCase method names. The runtime derives the kebab-case command slug from each name.
- * @property {string[]} [memberCommands] - Custom member commands as camelCase method names. The runtime derives the kebab-case command slug from each name.
+ * @property {Array<FrontendModelResourceCustomCommand>} [collectionCommands] - Custom collection commands. Each entry is a camelCase method name, or a `{name, args?, returnType?}` object declaring typed arguments and/or a response type. The runtime derives the kebab-case command slug from the name.
+ * @property {Array<FrontendModelResourceCustomCommand>} [memberCommands] - Custom member commands. Each entry is a camelCase method name, or a `{name, args?, returnType?}` object declaring typed arguments and/or a response type. The runtime derives the kebab-case command slug from the name.
  * @property {string[]} [builtInCollectionCommands] - Built-in collection command names (`index`, `create`).
  * @property {string[]} [builtInMemberCommands] - Built-in member command names (`find`, `update`, `destroy`, `attach`, `download`, `url`).
  * @property {string[]} [relationships] - Relationship names to expose in frontend models. Type and target model are inferred from the backend model's registered relationships.
  * @property {string} [primaryKey] - Primary key attribute name.
  * @property {FrontendModelResourceServerConfiguration} [server] - Optional legacy backend behavior overrides for built-in frontend actions.
  */
+/**
+ * Object form of a custom command entry, declaring its typed arguments and/or
+ * response type alongside the command name.
+ * @typedef {object} FrontendModelResourceCustomCommandObject
+ * @property {string} name - camelCase command method name.
+ * @property {Array<{name: string, type: string}>} [args] - Typed command arguments; each generates a named, typed method parameter mapped positionally into the command payload. `type` is a JSDoc type string.
+ * @property {string} [returnType] - JSDoc type for the command response. When set, the generated method is typed `Promise<returnType>` instead of `Promise<Record<string, ?>>`. Emitted verbatim into the generated frontend model, so it must resolve there.
+ */
+/**
+ * A custom command entry: a plain camelCase method name, or an object declaring
+ * typed args and/or a response type.
+ * @typedef {string | FrontendModelResourceCustomCommandObject} FrontendModelResourceCustomCommand
+ */
 /**
  * @typedef {Omit<FrontendModelResourceConfiguration, "abilities" | "builtInCollectionCommands" | "builtInMemberCommands" | "collectionCommands" | "commands" | "memberCommands"> & {
  *   abilities: FrontendModelResourceAbilitiesConfiguration
  *   builtInCollectionCommands: Record<string, string>
  *   builtInMemberCommands: Record<string, string>
  *   collectionCommands: Record<string, string>
+ *   commandMetadata: Record<string, {args: Array<{name: string, type: string}>, returnType: string | null}>
  *   memberCommands: Record<string, string>
  * }} NormalizedFrontendModelResourceConfiguration
  */
@@ -1043,13 +1057,13 @@ export type FrontendModelResourceConfiguration = {
      */
     commands?: string[] | undefined;
     /**
-     * - Custom collection commands as camelCase method names. The runtime derives the kebab-case command slug from each name.
+     * - Custom collection commands. Each entry is a camelCase method name, or a `{name, args?, returnType?}` object declaring typed arguments and/or a response type. The runtime derives the kebab-case command slug from the name.
      */
-    collectionCommands?: string[] | undefined;
+    collectionCommands?: FrontendModelResourceCustomCommand[] | undefined;
     /**
-     * - Custom member commands as camelCase method names. The runtime derives the kebab-case command slug from each name.
+     * - Custom member commands. Each entry is a camelCase method name, or a `{name, args?, returnType?}` object declaring typed arguments and/or a response type. The runtime derives the kebab-case command slug from the name.
      */
-    memberCommands?: string[] | undefined;
+    memberCommands?: FrontendModelResourceCustomCommand[] | undefined;
     /**
      * - Built-in collection command names (`index`, `create`).
      */
@@ -1071,11 +1085,44 @@ export type FrontendModelResourceConfiguration = {
      */
     server?: FrontendModelResourceServerConfiguration | undefined;
 };
+/**
+ * Object form of a custom command entry, declaring its typed arguments and/or
+ * response type alongside the command name.
+ */
+export type FrontendModelResourceCustomCommandObject = {
+    /**
+     * - camelCase command method name.
+     */
+    name: string;
+    /**
+     * - Typed command arguments; each generates a named, typed method parameter mapped positionally into the command payload. `type` is a JSDoc type string.
+     */
+    args?: {
+        name: string;
+        type: string;
+    }[] | undefined;
+    /**
+     * - JSDoc type for the command response. When set, the generated method is typed `Promise<returnType>` instead of `Promise<Record<string, ?>>`. Emitted verbatim into the generated frontend model, so it must resolve there.
+     */
+    returnType?: string | undefined;
+};
+/**
+ * A custom command entry: a plain camelCase method name, or an object declaring
+ * typed args and/or a response type.
+ */
+export type FrontendModelResourceCustomCommand = string | FrontendModelResourceCustomCommandObject;
 export type NormalizedFrontendModelResourceConfiguration = Omit<FrontendModelResourceConfiguration, "abilities" | "builtInCollectionCommands" | "builtInMemberCommands" | "collectionCommands" | "commands" | "memberCommands"> & {
     abilities: FrontendModelResourceAbilitiesConfiguration;
     builtInCollectionCommands: Record<string, string>;
     builtInMemberCommands: Record<string, string>;
     collectionCommands: Record<string, string>;
+    commandMetadata: Record<string, {
+        args: Array<{
+            name: string;
+            type: string;
+        }>;
+        returnType: string | null;
+    }>;
     memberCommands: Record<string, string>;
 };
 export type FrontendModelResourceClassType = Omit<typeof import("./frontend-model-resource/base-resource.js").default, never> & {