@jskit-ai/crud-core 0.1.63 → 0.1.64

package/src/server/listQueryValidators.js

@@ -1,53 +1,38 @@
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
 import {
-  normalizeObjectInput,
-  positiveIntegerValidator,
   cursorPaginationQueryValidator
 } from "@jskit-ai/kernel/shared/validators";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { resolveCrudParentFilterKeys as resolveSharedCrudParentFilterKeys } from "@jskit-ai/kernel/shared/support/crudLookup";
 
 const listSearchQueryValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      q: Type.Optional(Type.String({ minLength: 0 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    if (!Object.hasOwn(source, "q")) {
-      return {};
+  schema: createSchema({
+    q: {
+      type: "string",
+      required: false
     }
-
-    return {
-      q: normalizeText(source.q)
-    };
-  }
+  }),
+  mode: "patch"
 });
 
 const lookupIncludeQueryValidator = Object.freeze({
-  schema: Type.Object(
-    {
-      include: Type.Optional(Type.String({ minLength: 0 }))
-    },
-    { additionalProperties: false }
-  ),
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    if (!Object.hasOwn(source, "include")) {
-      return {};
+  schema: createSchema({
+    include: {
+      type: "string",
+      required: false
     }
-
-    return {
-      include: normalizeText(source.include)
-    };
-  }
+  }),
+  mode: "patch"
 });
 
 function resolveCrudListUsesOrderedCursor(list = {}) {
-  const orderBy = Array.isArray(list?.orderBy) ? list.orderBy : [];
-  for (const entry of orderBy) {
+  const entries = Array.isArray(list?.orderBy)
+    ? list.orderBy
+    : list?.orderBy == null
+      ? []
+      : [list.orderBy];
+
+  for (const entry of entries) {
     if (typeof entry === "string" && normalizeText(entry)) {
       return true;
     }
@@ -65,32 +50,20 @@ function createCrudCursorPaginationQueryValidator(list = {}) {
   }
 
   return Object.freeze({
-    schema: Type.Object(
-      {
-        cursor: Type.Optional(
-          Type.Union([
-            positiveIntegerValidator.schema,
-            Type.String({ minLength: 1 })
-          ])
-        ),
-        limit: Type.Optional(positiveIntegerValidator.schema)
+    schema: createSchema({
+      cursor: {
+        type: "string",
+        required: false,
+        minLength: 1
       },
-      { additionalProperties: false }
-    ),
-    normalize(payload = {}) {
-      const source = normalizeObjectInput(payload);
-      const normalized = {};
-
-      if (Object.hasOwn(source, "cursor")) {
-        normalized.cursor = normalizeText(source.cursor);
+      limit: {
+        type: "number",
+        required: false,
+        min: 1,
+        unsigned: true
       }
-
-      if (Object.hasOwn(source, "limit")) {
-        normalized.limit = positiveIntegerValidator.normalize(source.limit);
-      }
-
-      return normalized;
-    }
+    }),
+    mode: "patch"
   });
 }
 
@@ -102,27 +75,16 @@ function createCrudParentFilterQueryValidator(resource = {}) {
   const keys = resolveCrudParentFilterKeys(resource);
   const schemaProperties = {};
   for (const key of keys) {
-    schemaProperties[key] = Type.Optional(Type.String({ minLength: 1 }));
+    schemaProperties[key] = {
+      type: "string",
+      required: false,
+      minLength: 1
+    };
   }
 
   return Object.freeze({
-    schema: Type.Object(schemaProperties, { additionalProperties: false }),
-    normalize(payload = {}) {
-      const source = normalizeObjectInput(payload);
-      const normalized = {};
-      for (const key of keys) {
-        if (!Object.hasOwn(source, key)) {
-          continue;
-        }
-
-        const value = normalizeText(source[key]);
-        if (value) {
-          normalized[key] = value;
-        }
-      }
-
-      return normalized;
-    }
+    schema: createSchema(schemaProperties),
+    mode: "patch"
   });
 }
 

package/src/server/lookupHydration.js

@@ -6,6 +6,7 @@ import {
   normalizeCrudLookupContainerKey,
   resolveCrudLookupContainerKey
 } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { buildCrudFieldContractMap } from "@jskit-ai/kernel/shared/support/crudFieldContract";
 import { normalizeCrudLookupApiPath } from "./lookupPathSupport.js";
 
 const DEFAULT_LOOKUP_INCLUDE = "*";
@@ -136,7 +137,9 @@ function createCrudLookupRuntime(resource = {}, { outputKeys = [] } = {}) {
       .filter(Boolean)
   );
 
-  const sourceEntries = Array.isArray(resource?.fieldMeta) ? resource.fieldMeta : [];
+  const sourceEntries = Object.values(buildCrudFieldContractMap(resource, {
+    context: "crud lookup runtime field contract"
+  }));
   const lookupEntries = [];
   const seenKeys = new Set();
 

package/src/server/repositorySupport.js

@@ -6,23 +6,25 @@ import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
 import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
+import { normalizeSchemaDefinition } from "@jskit-ai/kernel/shared/validators";
+import {
+  buildCrudFieldContractMap,
+  resolveCrudFieldSchemaProperties,
+  CRUD_FIELD_STORAGE_COLUMN,
+  CRUD_FIELD_STORAGE_VIRTUAL,
+  CRUD_FIELD_WRITE_SERIALIZER_DATETIME_UTC
+} from "@jskit-ai/kernel/shared/support/crudFieldContract";
 import { toSnakeCase } from "@jskit-ai/kernel/shared/support/stringCase";
 import {
   resolveCrudLookupContainerKey,
   resolveCrudLookupFieldKeys
 } from "@jskit-ai/kernel/shared/support/crudLookup";
-import {
-  CRUD_FIELD_REPOSITORY_STORAGE_COLUMN,
-  CRUD_FIELD_REPOSITORY_WRITE_SERIALIZER_DATETIME_UTC,
-  CRUD_FIELD_REPOSITORY_STORAGE_VIRTUAL,
-  isCrudRuntimeOutputOnlyFieldKey,
-  normalizeCrudFieldRepositoryConfig
-} from "../shared/crudFieldMetaSupport.js";
+import { isCrudRuntimeOutputOnlyFieldKey } from "../shared/crudFieldSupport.js";
 
 const DEFAULT_LIST_LIMIT = 20;
 const MAX_LIST_LIMIT = 100;
 const CRUD_WRITE_SERIALIZERS = Object.freeze({
-  [CRUD_FIELD_REPOSITORY_WRITE_SERIALIZER_DATETIME_UTC]: (value) => toDatabaseDateTimeUtc(value)
+  [CRUD_FIELD_WRITE_SERIALIZER_DATETIME_UTC]: (value) => toDatabaseDateTimeUtc(value)
 });
 
 function normalizeCrudListCursor(cursor = null, { allowEmpty = true } = {}) {
@@ -93,7 +95,7 @@ function buildRepositoryColumnMetadata({
     .filter(Boolean);
 
   const deriveMapping = (key) => {
-    if (fieldStorageByKey?.[key] !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+    if (fieldStorageByKey?.[key] !== CRUD_FIELD_STORAGE_COLUMN) {
       return null;
     }
     const column = resolveColumnName(key, columnOverrides);
@@ -116,105 +118,55 @@ function buildRepositoryColumnMetadata({
   });
 }
 
-function resolveOptionalObjectSchemaProperties(schema, options = {}) {
-  if (!schema) {
+function resolveOptionalFieldDefinitions(definition, options = {}) {
+  if (!definition) {
     return {};
   }
-  return requireObjectSchemaProperties(schema, options);
+  return requireFieldDefinitions(definition, options);
 }
 
-function requireObjectSchemaProperties(schema, { context = "crudRepository", schemaLabel = "schema" } = {}) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-    throw new TypeError(`${context} requires ${schemaLabel} to be an object schema.`);
+function requireFieldDefinitions(definition, {
+  context = "crudRepository",
+  schemaLabel = "schema definition",
+  defaultMode = "patch"
+} = {}) {
+  const normalized = normalizeSchemaDefinition(definition, {
+    context: `${context} ${schemaLabel}`,
+    defaultMode
+  });
+  if (!normalized) {
+    throw new TypeError(`${context} requires ${schemaLabel}.`);
   }
 
-  const properties = schema.properties;
+  const properties = resolveCrudFieldSchemaProperties(normalized, {
+    context: `${context} ${schemaLabel}`
+  });
   if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
-    throw new TypeError(`${context} requires ${schemaLabel}.properties.`);
+    throw new TypeError(`${context} requires ${schemaLabel} field definitions.`);
   }
 
   return properties;
 }
 
-function normalizeResourceFieldMetaEntries(fieldMeta = []) {
-  if (!Array.isArray(fieldMeta)) {
-    return [];
-  }
-
-  const normalized = [];
-  const seenKeys = new Set();
-  for (const rawEntry of fieldMeta) {
-    if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) {
-      continue;
-    }
-
-    const key = normalizeText(rawEntry.key);
-    if (!key || seenKeys.has(key)) {
-      continue;
-    }
-    seenKeys.add(key);
-    normalized.push(rawEntry);
-  }
-
-  return normalized;
+function resolveFieldDefinitionType(definition = {}) {
+  return normalizeText(definition?.type).toLowerCase();
 }
 
-function schemaIncludesStringType(schema = {}) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-    return false;
-  }
-
-  const type = normalizeText(schema.type).toLowerCase();
-  if (type === "string") {
-    return true;
-  }
-
-  const variants = Array.isArray(schema.anyOf)
-    ? schema.anyOf
-    : Array.isArray(schema.oneOf)
-      ? schema.oneOf
-      : [];
-  return variants.some((entry) => schemaIncludesStringType(entry));
+function definitionIncludesStringType(definition = {}) {
+  return resolveFieldDefinitionType(definition) === "string";
 }
 
-function schemaIncludesDateTimeFormat(schema = {}) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-    return false;
-  }
-
-  if (normalizeText(schema.format).toLowerCase() === "date-time") {
-    return true;
-  }
-
-  const variants = Array.isArray(schema.anyOf)
-    ? schema.anyOf
-    : Array.isArray(schema.oneOf)
-      ? schema.oneOf
-      : [];
-  return variants.some((entry) => schemaIncludesDateTimeFormat(entry));
+function definitionIncludesDateTimeType(definition = {}) {
+  return resolveFieldDefinitionType(definition) === "datetime";
 }
 
-function schemaIncludesRecordIdType(schema = {}) {
-  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-    return false;
-  }
-
-  const type = Array.isArray(schema.type)
-    ? schema.type.map((entry) => normalizeText(entry).toLowerCase()).filter(Boolean)
-    : normalizeText(schema.type).toLowerCase();
-  const hasStringType = Array.isArray(type)
-    ? type.includes("string")
-    : type === "string";
-  if (hasStringType && normalizeText(schema.pattern) === RECORD_ID_PATTERN) {
+function definitionIncludesRecordIdType(definition = {}) {
+  const type = resolveFieldDefinitionType(definition);
+  if (type === "id") {
     return true;
   }
 
-  const variants = Array.isArray(schema.anyOf)
-    ? schema.anyOf
-    : Array.isArray(schema.oneOf)
-      ? schema.oneOf
-      : [];
-  return variants.some((entry) => schemaIncludesRecordIdType(entry));
+  return type === "string" && normalizeText(definition?.pattern) === RECORD_ID_PATTERN;
 }
 
 function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRepository" } = {}) {
@@ -227,20 +179,20 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
     throw new TypeError(`${context} requires resource.operations.`);
   }
 
-  const outputSchema = operations?.view?.outputValidator?.schema;
-  const writeSchema = operations?.create?.bodyValidator?.schema;
-  const patchSchema = operations?.patch?.bodyValidator?.schema;
-  const outputProperties = requireObjectSchemaProperties(outputSchema, {
+  const outputProperties = requireFieldDefinitions(operations?.view?.output, {
     context,
-    schemaLabel: "operations.view.outputValidator.schema"
+    schemaLabel: "operations.view.output",
+    defaultMode: "replace"
   });
-  const writeProperties = requireObjectSchemaProperties(writeSchema, {
+  const writeProperties = requireFieldDefinitions(operations?.create?.body, {
     context,
-    schemaLabel: "operations.create.bodyValidator.schema"
+    schemaLabel: "operations.create.body",
+    defaultMode: "create"
   });
-  const patchProperties = resolveOptionalObjectSchemaProperties(patchSchema, {
+  const patchProperties = resolveOptionalFieldDefinitions(operations?.patch?.body, {
     context,
-    schemaLabel: "operations.patch.bodyValidator.schema"
+    schemaLabel: "operations.patch.body",
+    defaultMode: "patch"
   });
   const lookupContainerKey = resolveCrudLookupContainerKey(resource, {
     context: `${context} resource.contract.lookup.containerKey`
@@ -258,35 +210,33 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
   const fieldStorageByKey = {};
   const columnOverrides = {};
   const writeSerializerByKey = {};
-  for (const entry of normalizeResourceFieldMetaEntries(resource.fieldMeta)) {
+  for (const entry of Object.values(buildCrudFieldContractMap(resource, {
+    context: `${context} resource field contract`
+  }))) {
     const key = normalizeText(entry.key);
     if (!key) {
       continue;
     }
-    const repositoryConfig = normalizeCrudFieldRepositoryConfig(entry, {
-      context: `${context} resource.fieldMeta`,
-      fieldKey: key
-    });
-    fieldStorageByKey[key] = repositoryConfig.storage;
-    if (repositoryConfig.column) {
-      columnOverrides[key] = repositoryConfig.column;
+    fieldStorageByKey[key] = entry?.storage?.mode || CRUD_FIELD_STORAGE_COLUMN;
+    if (entry?.storage?.column) {
+      columnOverrides[key] = entry.storage.column;
     }
-    if (repositoryConfig.writeSerializer) {
-      writeSerializerByKey[key] = repositoryConfig.writeSerializer;
+    if (entry?.storage?.writeSerializer) {
+      writeSerializerByKey[key] = entry.storage.writeSerializer;
     }
   }
 
   for (const key of [...outputKeys, ...writeKeys]) {
     if (!fieldStorageByKey[key]) {
-      fieldStorageByKey[key] = CRUD_FIELD_REPOSITORY_STORAGE_COLUMN;
+      fieldStorageByKey[key] = CRUD_FIELD_STORAGE_COLUMN;
     }
   }
 
   const virtualOutputKeys = [];
   const columnBackedOutputKeys = [];
   for (const key of outputKeys) {
-    const storage = fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN;
-    if (storage === CRUD_FIELD_REPOSITORY_STORAGE_VIRTUAL) {
+    const storage = fieldStorageByKey[key] || CRUD_FIELD_STORAGE_COLUMN;
+    if (storage === CRUD_FIELD_STORAGE_VIRTUAL) {
       virtualOutputKeys.push(key);
       continue;
     }
@@ -296,22 +246,22 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
   for (const key of virtualOutputKeys) {
     if (Object.hasOwn(writeProperties, key)) {
       throw new Error(
-        `${context} resource create schema field "${key}" cannot use repository.storage "virtual".`
+        `${context} resource create schema field "${key}" cannot use storage.virtual.`
       );
     }
     if (Object.hasOwn(patchProperties, key)) {
       throw new Error(
-        `${context} resource patch schema field "${key}" cannot use repository.storage "virtual".`
+        `${context} resource patch schema field "${key}" cannot use storage.virtual.`
       );
     }
   }
 
   const listSearchColumns = [];
-  for (const [key, schema] of Object.entries(outputProperties)) {
-    if ((fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+  for (const [key, definition] of Object.entries(outputProperties)) {
+    if ((fieldStorageByKey[key] || CRUD_FIELD_STORAGE_COLUMN) !== CRUD_FIELD_STORAGE_COLUMN) {
       continue;
     }
-    if (!schemaIncludesStringType(schema)) {
+    if (!definitionIncludesStringType(definition)) {
       continue;
     }
 
@@ -324,7 +274,7 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
 
   const parentFilterColumns = {};
   for (const key of resolveCrudLookupFieldKeys(resource, { allowKeys: writeKeys })) {
-    if ((fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+    if ((fieldStorageByKey[key] || CRUD_FIELD_STORAGE_COLUMN) !== CRUD_FIELD_STORAGE_COLUMN) {
       continue;
     }
     const columnName = resolveColumnName(key, columnOverrides);
@@ -335,14 +285,14 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
   }
 
   const outputRecordIdKeys = [];
-  for (const [key, schema] of Object.entries(outputProperties)) {
-    if (schemaIncludesRecordIdType(schema)) {
+  for (const [key, definition] of Object.entries(outputProperties)) {
+    if (definitionIncludesRecordIdType(definition)) {
       outputRecordIdKeys.push(key);
     }
   }
 
   for (const key of writeKeys) {
-    if ((fieldStorageByKey[key] || CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) !== CRUD_FIELD_REPOSITORY_STORAGE_COLUMN) {
+    if ((fieldStorageByKey[key] || CRUD_FIELD_STORAGE_COLUMN) !== CRUD_FIELD_STORAGE_COLUMN) {
       continue;
     }
 
@@ -350,12 +300,12 @@ function deriveRepositoryMappingFromResource(resource = {}, { context = "crudRep
       continue;
     }
 
-    const schema = writeProperties[key] || patchProperties[key];
-    if (!schemaIncludesDateTimeFormat(schema)) {
+    const definition = writeProperties[key] || patchProperties[key];
+    if (!definitionIncludesDateTimeType(definition)) {
       continue;
     }
 
-    writeSerializerByKey[key] = CRUD_FIELD_REPOSITORY_WRITE_SERIALIZER_DATETIME_UTC;
+    writeSerializerByKey[key] = CRUD_FIELD_WRITE_SERIALIZER_DATETIME_UTC;
   }
 
   return Object.freeze({