@svadmin/core 0.49.1 → 0.52.0

package/src/resource-schemas.ts

@@ -0,0 +1,371 @@
+import { Type, type Static, type TSchema } from '@sinclair/typebox';
+import { checkExact, createExactSchemaValidator } from './schema-validation';
+import { attachAbortSignal, detachAbortSignal, snapshotPlainData } from './plain-data';
+import { decodeBaseRecord, decodeOneResult, decodeManyResult, decodeListResult } from './record-decoder';
+import { HttpError } from './types';
+import { captureResourceSchemas, captureResourceTransport } from './resource-transport-config';
+import type {
+  BaseRecord, DataProvider, GetListParams, GetOneParams, GetManyParams,
+  CreateParams, CreateManyParams, UpdateParams, UpdateManyParams,
+  DeleteParams, DeleteManyParams,
+  ResourceInputOperation,
+  GetOneResult, GetManyResult, GetListResult,
+} from './types';
+
+export interface ResourceSchemas {
+  /** Schema for complete records returned by standard CRUD operations. */
+  record: TSchema;
+  /** Required to enable create/createMany. */
+  create?: TSchema;
+  /** Required to enable update/updateMany. */
+  update?: TSchema;
+  /** Without a schema, delete operations only accept undefined variables. */
+  delete?: TSchema;
+  /** Referenced schemas used by Type.Ref. */
+  references?: readonly TSchema[];
+}
+
+export type ResourceSchemaMap = Readonly<Record<string, ResourceSchemas>>;
+export type InferSchemaResourceMap<TSchemas extends ResourceSchemaMap> = {
+  [R in keyof TSchemas]: unknown extends Static<TSchemas[R]['record']>
+    ? BaseRecord : Static<TSchemas[R]['record']>;
+};
+export type InferSchemaInputMap<TSchemas extends ResourceSchemaMap> = {
+  [R in keyof TSchemas]: {
+    [O in ResourceInputOperation]: TSchemas[R] extends Record<O, infer Schema extends TSchema>
+      ? unknown extends Static<Schema> ? unknown : Static<Schema>
+      : O extends 'delete' ? undefined : never;
+  };
+};
+type ResourceOperation = Exclude<keyof DataProvider, 'getApiUrl' | 'custom'>;
+const identity = Type.Union([Type.String(), Type.Number()]);
+const common = {
+  resource: Type.String({ minLength: 1 }),
+  meta: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+};
+const filter = Type.Recursive(Self => Type.Union([
+  Type.Object({
+    operator: Type.Union([Type.Literal('or'), Type.Literal('and')]),
+    value: Type.Array(Self),
+  }, { additionalProperties: false }),
+  Type.Object({
+    field: Type.String(),
+    operator: Type.Union([
+      Type.Literal('eq'), Type.Literal('ne'), Type.Literal('lt'), Type.Literal('gt'),
+      Type.Literal('lte'), Type.Literal('gte'), Type.Literal('contains'), Type.Literal('ncontains'),
+      Type.Literal('startswith'), Type.Literal('endswith'), Type.Literal('in'), Type.Literal('nin'),
+      Type.Literal('null'), Type.Literal('nnull'), Type.Literal('between'), Type.Literal('nbetween'),
+    ]),
+    value: Type.Unknown(),
+  }, { additionalProperties: false }),
+]));
+const requestSchemas = {
+  getList: Type.Object({
+    ...common,
+    filters: Type.Optional(Type.Array(filter)),
+    sorters: Type.Optional(Type.Array(Type.Object({
+      field: Type.String(), order: Type.Union([Type.Literal('asc'), Type.Literal('desc')]),
+    }, { additionalProperties: false }))),
+    pagination: Type.Optional(Type.Object({
+      current: Type.Optional(Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })),
+      pageSize: Type.Optional(Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER })),
+      mode: Type.Optional(Type.Union([Type.Literal('server'), Type.Literal('client'), Type.Literal('off')])),
+    }, { additionalProperties: false })),
+  }, { additionalProperties: false }),
+  getOne: Type.Object({ ...common, id: identity }, { additionalProperties: false }),
+  getMany: Type.Object({ ...common, ids: Type.Array(identity) }, { additionalProperties: false }),
+  create: Type.Object({ ...common, variables: Type.Unknown() }, { additionalProperties: false }),
+  createMany: Type.Object({ ...common, variables: Type.Array(Type.Unknown()) }, { additionalProperties: false }),
+  update: Type.Object({ ...common, id: identity, variables: Type.Unknown() }, { additionalProperties: false }),
+  updateMany: Type.Object({ ...common, ids: Type.Array(identity), variables: Type.Unknown() }, { additionalProperties: false }),
+  deleteOne: Type.Object({ ...common, id: identity, variables: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),
+  deleteMany: Type.Object({ ...common, ids: Type.Array(identity), variables: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),
+};
+
+function createSchemaBoundary(schemas: ResourceSchemaMap) {
+  const definitions = captureResourceSchemas(schemas);
+  const validators = new WeakMap<TSchema[], WeakMap<TSchema, ReturnType<typeof createExactSchemaValidator>>>();
+  const registry = new Map([...definitions].map(([resource, definition]) => {
+    // DataProvider records must remain objects even when a broad schema is supplied.
+    const record = Type.Intersect([Type.Object({}), definition.record]);
+    return [resource, {
+      ...definition,
+      references: [...(definition.references ?? [])],
+      one: Type.Object({ data: record }),
+      many: Type.Object({ data: Type.Array(record) }),
+      list: Type.Object({ data: Type.Array(record), total: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }) }),
+    }];
+  }));
+
+  function required(resource: string, operation: string): never {
+    throw new HttpError('A resource schema is required for this operation', 400, undefined, {
+      code: 'RESOURCE_SCHEMA_REQUIRED',
+      details: { resource, operation, phase: 'input', writeMayHaveSucceeded: false },
+    });
+  }
+
+  function resolve(resource: string, operation: ResourceOperation) {
+    return registry.get(resource) ?? required(resource, operation);
+  }
+
+  function invalidData(operation: ResourceOperation, phase: 'input' | 'response', resource = '', writeMayHaveSucceeded = false): never {
+    throw new HttpError(phase === 'input' ? 'Invalid resource input' : 'Invalid provider response',
+      phase === 'input' ? 422 : 502, undefined, {
+        code: phase === 'input' ? 'INVALID_RESOURCE_INPUT' : 'INVALID_PROVIDER_RESPONSE',
+        details: { resource, operation, phase, writeMayHaveSucceeded },
+      });
+  }
+
+  function captureRequest<S extends TSchema>(schema: S, value: unknown, operation: ResourceOperation): Static<S> {
+    try {
+      const detached = detachAbortSignal(value);
+      const signal = detached.signal;
+      let input = detached.rest;
+      if ((operation === 'deleteOne' || operation === 'deleteMany') && typeof value === 'object' && value !== null) {
+        // Undefined delete variables represent an absent body, not a JSON value.
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        const descriptor = descriptors['variables'];
+        const variable: unknown = descriptor && 'value' in descriptor ? descriptor.value : null;
+        if (descriptor?.enumerable && variable === undefined) {
+          const prototype: unknown = Object.getPrototypeOf(value);
+          if (Array.isArray(value) || (prototype !== Object.prototype && prototype !== null)) return invalidData(operation, 'input');
+          delete descriptors['variables'];
+          input = Object.defineProperties({}, descriptors);
+        }
+      }
+      const candidate = snapshotPlainData(input);
+      if (checkExact(schema, candidate) && typeof candidate === 'object' && candidate !== null) {
+        return attachAbortSignal(candidate, signal);
+      }
+    } catch {
+      // Capture failures are input errors and must not run submitted accessors.
+    }
+    return invalidData(operation, 'input');
+  }
+
+  function validate(
+    schema: TSchema,
+    references: TSchema[],
+    value: unknown,
+    resource: string,
+    operation: ResourceOperation,
+    phase: 'input' | 'response',
+    writeMayHaveSucceeded = false,
+  ): void {
+    let issues: { path: string; message: string }[];
+    try {
+      let scopedValidators = validators.get(references);
+      if (!scopedValidators) {
+        scopedValidators = new WeakMap();
+        validators.set(references, scopedValidators);
+      }
+      let validator = scopedValidators.get(schema);
+      if (!validator) {
+        validator = createExactSchemaValidator(schema, references);
+        scopedValidators.set(schema, validator);
+      }
+      if (validator.Check(value)) return;
+      // Do not include rejected values or raw responses in diagnostic details.
+      issues = [...validator.Errors(value)]
+        .map(({ path, message }) => ({ path, message }));
+    } catch {
+      throw new HttpError('Unable to evaluate resource schema', 500, undefined, {
+        code: 'RESOURCE_SCHEMA_INVALID',
+        details: { resource, operation, phase, writeMayHaveSucceeded },
+      });
+    }
+    const errors = phase === 'input' ? Object.fromEntries(issues.map(({ path, message }) => [
+      path.slice(1).split('/').map(part => part.replace(/~1/g, '/').replace(/~0/g, '~')).join('.') || '_root',
+      message,
+    ])) : undefined;
+    throw new HttpError(
+      phase === 'input' ? 'Invalid resource input' : 'Invalid provider response',
+      phase === 'input' ? 422 : 502,
+      errors,
+      {
+        code: phase === 'input' ? 'INVALID_RESOURCE_INPUT' : 'INVALID_PROVIDER_RESPONSE',
+        details: { resource, operation, phase, issues, writeMayHaveSucceeded },
+      },
+    );
+  }
+
+  function input(
+    resource: string,
+    operation: ResourceOperation,
+    kind: 'create' | 'update' | 'delete',
+    variables: unknown,
+    batch = false,
+  ) {
+    const definition = resolve(resource, operation);
+    const schema = definition[kind] ?? (kind === 'delete' ? Type.Undefined() : required(resource, operation));
+    validate(batch ? Type.Array(schema) : schema, definition.references, variables, resource, operation, 'input');
+    return definition;
+  }
+
+  function output(definition: ReturnType<typeof resolve>, resource: string, operation: ResourceOperation,
+    kind: 'one', result: unknown, writeMayHaveSucceeded?: boolean): GetOneResult;
+  function output(definition: ReturnType<typeof resolve>, resource: string, operation: ResourceOperation,
+    kind: 'many', result: unknown, writeMayHaveSucceeded?: boolean): GetManyResult;
+  function output(definition: ReturnType<typeof resolve>, resource: string, operation: ResourceOperation,
+    kind: 'list', result: unknown, writeMayHaveSucceeded?: boolean): GetListResult;
+  function output(
+    definition: ReturnType<typeof resolve>,
+    resource: string,
+    operation: ResourceOperation,
+    kind: 'one' | 'many' | 'list',
+    result: unknown,
+    writeMayHaveSucceeded = false,
+  ): GetOneResult | GetManyResult | GetListResult {
+    let captured: unknown;
+    try { captured = snapshotPlainData(result); }
+    catch { return invalidData(operation, 'response', resource, writeMayHaveSucceeded); }
+    validate(definition[kind], definition.references, captured, resource, operation, 'response', writeMayHaveSucceeded);
+    switch (kind) {
+      case 'one': return decodeOneResult(captured, decodeBaseRecord, writeMayHaveSucceeded);
+      case 'many': return decodeManyResult(captured, decodeBaseRecord, writeMayHaveSucceeded);
+      case 'list': return decodeListResult(captured, decodeBaseRecord);
+    }
+  }
+
+  function prepare<O extends ResourceOperation>(operation: O, request: unknown) {
+    if (typeof operation !== 'string' || !Object.hasOwn(requestSchemas, operation)) {
+      throw new HttpError('Invalid resource operation', 422, undefined, {
+        code: 'INVALID_RESOURCE_INPUT', details: { phase: 'input', writeMayHaveSucceeded: false },
+      });
+    }
+    const params = captureRequest(requestSchemas[operation], request, operation);
+    const definition = resolve(params.resource, operation);
+    const variables = 'variables' in params ? params.variables : undefined;
+    switch (operation) {
+      case 'create': case 'createMany':
+        input(params.resource, operation, 'create', variables, operation === 'createMany');
+        break;
+      case 'update': case 'updateMany':
+        input(params.resource, operation, 'update', variables);
+        break;
+      case 'deleteOne': case 'deleteMany':
+        input(params.resource, operation, 'delete', variables);
+        break;
+    }
+    return { params, definition };
+  }
+  return { prepare, output, required };
+}
+
+/** Internal contract composition reuses input validation, never an unchecked transport. */
+export function createResourceRequestValidator(schemas: ResourceSchemaMap) {
+  const boundary = createSchemaBoundary(schemas);
+  return <O extends ResourceOperation>(operation: O, request: unknown) => boundary.prepare(operation, request).params;
+}
+
+function providerFailure(cause: unknown, resource: string, operation: ResourceOperation): HttpError {
+  let status = 502;
+  try {
+    if (typeof cause === 'object' && cause !== null) {
+      const candidate: unknown = Object.getOwnPropertyDescriptor(cause, 'statusCode')?.value;
+      if (typeof candidate === 'number' && Number.isInteger(candidate) && candidate >= 400 && candidate <= 599) {
+        status = candidate;
+      }
+    }
+  } catch {
+    // Reflection failures do not expose provider values or supply authentication status.
+  }
+  return new HttpError('Resource provider failed', status, undefined, {
+    code: 'RESOURCE_PROVIDER_FAILED',
+    details: { resource, operation, phase: 'transport', writeMayHaveSucceeded: !operation.startsWith('get') },
+  });
+}
+
+/**
+ * Validates standard CRUD payloads and responses without coercing or stripping data.
+ * Unregistered resources, unconfigured writes, and custom endpoints fail closed.
+ */
+export function withResourceSchemas(provider: DataProvider, schemas: ResourceSchemaMap): Readonly<DataProvider> {
+  const { prepare, output, required } = createSchemaBoundary(schemas);
+  const transport = captureResourceTransport(provider);
+  async function dispatch(resource: string, operation: ResourceOperation, invoke: () => unknown): Promise<unknown> {
+    try { return await invoke(); }
+    catch (cause: unknown) { throw providerFailure(cause, resource, operation); }
+  }
+
+  const adapted: DataProvider = {
+    getApiUrl: () => {
+      try {
+        const url = transport.getApiUrl();
+        if (typeof url === 'string') return url;
+      } catch {
+        // Configuration diagnostics must not disclose arbitrary provider return values.
+      }
+      throw new HttpError('Invalid resource provider URL', 502, undefined, { code: 'INVALID_DATA_PROVIDER' });
+    },
+    getList: async (request: GetListParams) => {
+      const { params, definition } = prepare('getList', request);
+      return output(definition, params.resource, 'getList', 'list',
+        await dispatch(params.resource, 'getList', () => transport.getList(params)));
+    },
+    getOne: async (request: GetOneParams) => {
+      const { params, definition } = prepare('getOne', request);
+      return output(definition, params.resource, 'getOne', 'one',
+        await dispatch(params.resource, 'getOne', () => transport.getOne(params)));
+    },
+    create: async (request: CreateParams<unknown>) => {
+      const { params, definition } = prepare('create', request);
+      const resource = params.resource;
+      return output(definition, resource, 'create', 'one',
+        await dispatch(resource, 'create', () => transport.create(params)), true);
+    },
+    update: async (request: UpdateParams<unknown>) => {
+      const { params, definition } = prepare('update', request);
+      const resource = params.resource;
+      return output(definition, resource, 'update', 'one',
+        await dispatch(resource, 'update', () => transport.update(params)), true);
+    },
+    deleteOne: async (request: DeleteParams<unknown>) => {
+      const { params, definition } = prepare('deleteOne', request);
+      const resource = params.resource;
+      return output(definition, resource, 'deleteOne', 'one',
+        await dispatch(resource, 'deleteOne', () => transport.deleteOne(params)), true);
+    },
+  };
+
+  const getMany = transport.getMany;
+  if (getMany) {
+    adapted.getMany = async (request: GetManyParams) => {
+      const { params, definition } = prepare('getMany', request);
+      return output(definition, params.resource, 'getMany', 'many',
+        await dispatch(params.resource, 'getMany', () => getMany(params)));
+    };
+  }
+  const createMany = transport.createMany;
+  if (createMany) {
+    adapted.createMany = async (request: CreateManyParams<unknown>) => {
+      const { params, definition } = prepare('createMany', request);
+      const resource = params.resource;
+      return output(definition, resource, 'createMany', 'many',
+        await dispatch(resource, 'createMany', () => createMany(params)), true);
+    };
+  }
+  const updateMany = transport.updateMany;
+  if (updateMany) {
+    adapted.updateMany = async (request: UpdateManyParams<unknown>) => {
+      const { params, definition } = prepare('updateMany', request);
+      const resource = params.resource;
+      return output(definition, resource, 'updateMany', 'many',
+        await dispatch(resource, 'updateMany', () => updateMany(params)), true);
+    };
+  }
+  const deleteMany = transport.deleteMany;
+  if (deleteMany) {
+    adapted.deleteMany = async (request: DeleteManyParams<unknown>) => {
+      const { params, definition } = prepare('deleteMany', request);
+      const resource = params.resource;
+      return output(definition, resource, 'deleteMany', 'many',
+        await dispatch(resource, 'deleteMany', () => deleteMany(params)), true);
+    };
+  }
+  if (transport.custom) {
+    adapted.custom = async () => required('', 'custom');
+  }
+
+  return Object.freeze(adapted);
+}

package/src/resource-transport-config.ts

@@ -0,0 +1,156 @@
+import { Hint, Kind, OptionalKind, ReadonlyKind, type TSchema } from '@sinclair/typebox';
+import { TypeGuard } from '@sinclair/typebox/type';
+import { HttpError } from './types';
+import type { DataProvider } from './types';
+import type { ResourceSchemas } from './resource-schemas';
+
+function invalidSchema(): never {
+  throw new HttpError('Invalid resource schema configuration', 400, undefined, {
+    code: 'RESOURCE_SCHEMA_INVALID', details: { phase: 'configuration', writeMayHaveSucceeded: false },
+  });
+}
+function invalidProvider(): never {
+  throw new HttpError('Invalid resource provider', 400, undefined, {
+    code: 'INVALID_DATA_PROVIDER', details: { phase: 'configuration', writeMayHaveSucceeded: false },
+  });
+}
+
+/** Configuration can carry TypeBox markers, but no getters, functions or foreign symbols. */
+function copySchemaData(value: unknown, ancestors = new Set<object>(), depth = 0): unknown {
+  if (depth > 128) return invalidSchema();
+  if (value === null || value === undefined || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'object' || value === null || ancestors.has(value)) return invalidSchema();
+  const array = Array.isArray(value);
+  const prototype: unknown = Object.getPrototypeOf(value);
+  if (!array && prototype !== Object.prototype && prototype !== null) return invalidSchema();
+  ancestors.add(value);
+  try {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const read = (key: PropertyKey): unknown => {
+      const descriptor: PropertyDescriptor | undefined = Reflect.get(descriptors, key);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return invalidSchema();
+      const field: unknown = descriptor.value;
+      return copySchemaData(field, ancestors, depth + 1);
+    };
+    if (array) {
+      const length: unknown = descriptors['length']?.value;
+      if (typeof length !== 'number' || !Number.isInteger(length) || length < 0 ||
+          Reflect.ownKeys(descriptors).length !== length + 1) return invalidSchema();
+      return Array.from({ length }, (_, index) => read(String(index)));
+    }
+    const copy: Record<PropertyKey, unknown> = {};
+    for (const key of Reflect.ownKeys(descriptors)) {
+      if (typeof key === 'symbol' && key !== Kind && key !== OptionalKind && key !== ReadonlyKind && key !== Hint) {
+        return invalidSchema();
+      }
+      const field = read(key);
+      if (typeof key === 'symbol' && typeof field !== 'string') return invalidSchema();
+      Object.defineProperty(copy, key, { value: field, enumerable: true, configurable: true, writable: true });
+    }
+    return copy;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+
+function schema(value: unknown): TSchema {
+  const copy = copySchemaData(value);
+  if (!TypeGuard.IsSchema(copy)) return invalidSchema();
+  return copy;
+}
+
+function fields(value: unknown): Map<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return invalidSchema();
+  const prototype: unknown = Object.getPrototypeOf(value);
+  if ((prototype !== Object.prototype && prototype !== null) || Object.getOwnPropertySymbols(value).length) return invalidSchema();
+  const result = new Map<string, unknown>();
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (!descriptor.enumerable || !('value' in descriptor)) return invalidSchema();
+    const field: unknown = descriptor.value;
+    result.set(key, field);
+  }
+  return result;
+}
+
+/** Copy each schema before lazy validators or transport callbacks can observe source mutations. */
+export function captureResourceSchemas(value: unknown): Map<string, ResourceSchemas> {
+  try {
+    const captured = new Map<string, ResourceSchemas>();
+    for (const [resource, definition] of fields(value)) {
+      if (!resource.trim()) return invalidSchema();
+      const input = fields(definition);
+      if ([...input.keys()].some(key => !['record', 'create', 'update', 'delete', 'references'].includes(key))) return invalidSchema();
+      const record = schema(input.get('record'));
+      const references: TSchema[] = [];
+      if (input.has('references')) {
+        const copied = copySchemaData(input.get('references'));
+        if (!Array.isArray(copied)) return invalidSchema();
+        const candidates: unknown[] = copied;
+        for (const candidate of candidates) {
+          if (!TypeGuard.IsSchema(candidate)) return invalidSchema();
+          references.push(candidate);
+        }
+      }
+      captured.set(resource, {
+        record, references,
+        ...(input.has('create') ? { create: schema(input.get('create')) } : {}),
+        ...(input.has('update') ? { update: schema(input.get('update')) } : {}),
+        ...(input.has('delete') ? { delete: schema(input.get('delete')) } : {}),
+      });
+    }
+    return captured;
+  } catch {
+    return invalidSchema();
+  }
+}
+
+/** Class prototype methods are supported without evaluating property accessors. */
+function member(provider: object, name: string): { value: unknown } | undefined {
+  let target: object | null = provider;
+  const seen = new Set<object>();
+  for (let depth = 0; target !== null && target !== Object.prototype && depth < 32; depth++) {
+    if (seen.has(target)) return invalidProvider();
+    seen.add(target);
+    const descriptor = Object.getOwnPropertyDescriptor(target, name);
+    if (descriptor) {
+      if (!('value' in descriptor)) return invalidProvider();
+      const value: unknown = descriptor.value;
+      return { value };
+    }
+    const prototype: unknown = Object.getPrototypeOf(target);
+    if (prototype !== null && typeof prototype !== 'object') return invalidProvider();
+    target = prototype;
+  }
+  if (target !== null && target !== Object.prototype) return invalidProvider();
+  return undefined;
+}
+
+type Invocation = (...args: unknown[]) => unknown;
+export function captureResourceTransport(provider: unknown) {
+  try {
+    if (typeof provider !== 'object' || provider === null || Array.isArray(provider)) return invalidProvider();
+    const owner = provider;
+    function capture(name: keyof DataProvider, required: true): Invocation;
+    function capture(name: keyof DataProvider, required: false): Invocation | undefined;
+    function capture(name: keyof DataProvider, required: boolean): Invocation | undefined {
+      const found = member(owner, name);
+      if (!required && found === undefined) return undefined;
+      const captured = found?.value;
+      if (typeof captured !== 'function') return invalidProvider();
+      return (...args: unknown[]): unknown => {
+        return Reflect.apply(captured, owner, args);
+      };
+    }
+    return Object.freeze({
+      getApiUrl: capture('getApiUrl', true), getList: capture('getList', true),
+      getOne: capture('getOne', true), create: capture('create', true),
+      update: capture('update', true), deleteOne: capture('deleteOne', true),
+      getMany: capture('getMany', false), createMany: capture('createMany', false),
+      updateMany: capture('updateMany', false), deleteMany: capture('deleteMany', false),
+      custom: capture('custom', false),
+    });
+  } catch {
+    return invalidProvider();
+  }
+}

package/src/route-parsing.ts

@@ -1,14 +1,14 @@
-export type ParsedResourceAction = {
-  action: 'list' | 'create' | 'edit' | 'show' | 'clone';
-  id?: string;
-};
+export type ParsedResourceAction =
+  | { action: 'list' | 'create' }
+  | { action: 'edit' | 'show' | 'clone'; id: string };
 
 export function parseResourceActionSegments(restSegments: string[]): ParsedResourceAction {
-  if (restSegments.length === 0) return { action: 'list' };
-  if (restSegments[0] === 'create') return { action: 'create' };
-  if (restSegments[0] === 'edit' && restSegments[1]) return { action: 'edit', id: restSegments[1] };
-  if (restSegments[0] === 'show' && restSegments[1]) return { action: 'show', id: restSegments[1] };
-  if (restSegments[0] === 'clone' && restSegments[1]) return { action: 'clone', id: restSegments[1] };
-  if (restSegments[1] === 'edit') return { action: 'edit', id: restSegments[0] };
-  return { action: 'show', id: restSegments[0] };
+  const [first, second] = restSegments;
+  if (first === undefined) return { action: 'list' };
+  if (first === 'create') return { action: 'create' };
+  if ((first === 'edit' || first === 'show' || first === 'clone') && second) {
+    return { action: first, id: second };
+  }
+  if (second === 'edit') return { action: 'edit', id: first };
+  return { action: 'show', id: first };
 }