@jskit-ai/workspaces-core 0.1.30 → 0.1.32

package/src/shared/resources/workspaceSettingsResource.js

@@ -1,169 +1,297 @@
-import { Type } from "typebox";
-import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import {
-  normalizeObjectInput,
-  createCursorListValidator,
-  normalizeSettingsFieldInput,
-  recordIdSchema
-} from "@jskit-ai/kernel/shared/validators";
-import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { workspaceSettingsFields } from "./workspaceSettingsFields.js";
-import { createWorkspaceRoleCatalog } from "../roles.js";
+import { createSchema } from "json-rest-schema";
+import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
+import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
+import { workspaceRoleCatalogSchema } from "./workspaceRoleCatalogSchema.js";
+import { normalizeWorkspaceHexColor, DEFAULT_WORKSPACE_DARK_PALETTE, DEFAULT_WORKSPACE_LIGHT_PALETTE } from "../settings.js";
 
-function buildCreateBodySchema() {
-  const properties = {};
-  for (const field of workspaceSettingsFields) {
-    properties[field.key] = field.required === false ? Type.Optional(field.inputSchema) : field.inputSchema;
-  }
+const WORKSPACE_SETTINGS_FIELD_KEYS = deepFreeze([
+  "lightPrimaryColor",
+  "lightSecondaryColor",
+  "lightSurfaceColor",
+  "lightSurfaceVariantColor",
+  "darkPrimaryColor",
+  "darkSecondaryColor",
+  "darkSurfaceColor",
+  "darkSurfaceVariantColor",
+  "invitesEnabled"
+]);
 
-  return Type.Object(properties, {
-    additionalProperties: false,
+const workspaceSettingsBodySchema = createSchema({
+  lightPrimaryColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
     messages: {
-      additionalProperties: "Unexpected field.",
-      default: "Invalid value."
+      required: "Light primary color is required.",
+      pattern: "Light primary color must be a hex color like #1867C0.",
+      default: "Light primary color must be a hex color like #1867C0."
+    }
+  },
+  lightSecondaryColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light secondary color is required.",
+      pattern: "Light secondary color must be a hex color like #48A9A6.",
+      default: "Light secondary color must be a hex color like #48A9A6."
+    }
+  },
+  lightSurfaceColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light surface color is required.",
+      pattern: "Light surface color must be a hex color like #FFFFFF.",
+      default: "Light surface color must be a hex color like #FFFFFF."
+    }
+  },
+  lightSurfaceVariantColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Light surface variant color is required.",
+      pattern: "Light surface variant color must be a hex color like #424242.",
+      default: "Light surface variant color must be a hex color like #424242."
+    }
+  },
+  darkPrimaryColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Dark primary color is required.",
+      pattern: "Dark primary color must be a hex color like #2196F3.",
+      default: "Dark primary color must be a hex color like #2196F3."
+    }
+  },
+  darkSecondaryColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Dark secondary color is required.",
+      pattern: "Dark secondary color must be a hex color like #54B6B2.",
+      default: "Dark secondary color must be a hex color like #54B6B2."
+    }
+  },
+  darkSurfaceColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Dark surface color is required.",
+      pattern: "Dark surface color must be a hex color like #212121.",
+      default: "Dark surface color must be a hex color like #212121."
+    }
+  },
+  darkSurfaceVariantColor: {
+    type: "string",
+    required: true,
+    minLength: 7,
+    maxLength: 7,
+    pattern: "^#[0-9A-Fa-f]{6}$",
+    messages: {
+      required: "Dark surface variant color is required.",
+      pattern: "Dark surface variant color must be a hex color like #C8C8C8.",
+      default: "Dark surface variant color must be a hex color like #C8C8C8."
+    }
+  },
+  invitesEnabled: {
+    type: "boolean",
+    required: true,
+    strictBoolean: true,
+    messages: {
+      required: "invitesEnabled is required.",
+      default: "invitesEnabled must be a boolean."
     }
-  });
-}
-
-function buildSettingsOutputSchema() {
-  const properties = {};
-  for (const field of workspaceSettingsFields) {
-    properties[field.key] = field.outputSchema;
   }
-  properties.invitesAvailable = Type.Boolean();
-  properties.invitesEffective = Type.Boolean();
-
-  return Type.Object(properties, { additionalProperties: false });
-}
-
-function buildResponseRecordSchema() {
-  return Type.Object(
-    {
-      workspace: Type.Object(
-        {
-          id: recordIdSchema,
-          slug: Type.String({ minLength: 1 }),
-          ownerUserId: recordIdSchema
-        },
-        { additionalProperties: false }
-      ),
-      settings: buildSettingsOutputSchema(),
-      roleCatalog: Type.Object(
-        {
-          collaborationEnabled: Type.Boolean(),
-          defaultInviteRole: Type.String(),
-          roles: Type.Array(Type.Object({}, { additionalProperties: true })),
-          assignableRoleIds: Type.Array(Type.String({ minLength: 1 }))
-        },
-        { additionalProperties: true }
-      )
-    },
-    { additionalProperties: false }
-  );
-}
+});
 
-function normalizeInput(payload = {}) {
-  return normalizeSettingsFieldInput(payload, workspaceSettingsFields);
-}
+const workspaceSettingsWorkspaceOutputSchema = createSchema({
+  id: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN },
+  slug: { type: "string", required: true, minLength: 1, maxLength: 120 },
+  ownerUserId: { type: "string", required: true, minLength: 1, pattern: RECORD_ID_PATTERN }
+});
 
-function normalizeOutput(payload = {}) {
-  const source = normalizeObjectInput(payload);
-  const workspace = normalizeObjectInput(source.workspace);
-  const settings = normalizeObjectInput(source.settings);
-  const normalizedSettings = {};
+const workspaceSettingsViewSchema = createSchema({
+  lightPrimaryColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  lightSecondaryColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  lightSurfaceColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  lightSurfaceVariantColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  darkPrimaryColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  darkSecondaryColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  darkSurfaceColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  darkSurfaceVariantColor: { type: "string", required: true, minLength: 7, maxLength: 7, pattern: "^#[0-9A-Fa-f]{6}$" },
+  invitesEnabled: { type: "boolean", required: true },
+  invitesAvailable: { type: "boolean", required: true },
+  invitesEffective: { type: "boolean", required: true }
+});
 
-  for (const field of workspaceSettingsFields) {
-    const rawValue = Object.hasOwn(settings, field.key)
-      ? settings[field.key]
-      : field.resolveDefault({
-          workspace,
-          settings
-        });
-    normalizedSettings[field.key] = field.normalizeOutput(rawValue, {
-      workspace,
-      settings
-    });
+const workspaceSettingsOutputSchema = createSchema({
+  workspace: {
+    type: "object",
+    required: true,
+    schema: workspaceSettingsWorkspaceOutputSchema
+  },
+  settings: {
+    type: "object",
+    required: true,
+    schema: workspaceSettingsViewSchema
+  },
+  roleCatalog: {
+    type: "object",
+    required: true,
+    schema: workspaceRoleCatalogSchema
   }
+});
 
-  const invitesEnabled = normalizedSettings.invitesEnabled !== false;
-  const invitesAvailable = settings.invitesAvailable !== false;
-  const invitesEffective =
-    typeof settings.invitesEffective === "boolean" ? settings.invitesEffective : invitesEnabled;
-  normalizedSettings.invitesEnabled = invitesEnabled;
-  normalizedSettings.invitesAvailable = invitesAvailable;
-  normalizedSettings.invitesEffective = invitesEffective;
-  const roleCatalog = normalizeObjectInput(source.roleCatalog);
-  const hasRoleCatalog =
-    Array.isArray(roleCatalog.roles) &&
-    roleCatalog.roles.length > 0 &&
-    Array.isArray(roleCatalog.assignableRoleIds);
-
-  return {
-    workspace: {
-      id: normalizeRecordId(workspace.id, { fallback: "" }),
-      slug: normalizeText(workspace.slug),
-      ownerUserId: normalizeRecordId(workspace.ownerUserId, { fallback: "" })
-    },
-    settings: normalizedSettings,
-    roleCatalog: hasRoleCatalog ? roleCatalog : createWorkspaceRoleCatalog()
-  };
+function normalizeWorkspaceColorInput(value) {
+  return normalizeWorkspaceHexColor(value);
 }
 
-const responseRecordValidator = Object.freeze({
-  get schema() {
-    return buildResponseRecordSchema();
-  },
-  normalize: normalizeOutput
-});
-
-const resource = {
+const workspaceSettingsResource = defineCrudResource({
   namespace: "workspaceSettings",
-  messages: {
-    validation: "Fix invalid workspace settings values and try again.",
-    saveSuccess: "Workspace settings updated.",
-    saveError: "Unable to update workspace settings.",
-    apiValidation: "Validation failed."
+  tableName: "workspace_settings",
+  idProperty: "workspace_id",
+  searchSchema: {
+    id: { type: "id", actualField: "id" }
   },
-  operations: {
-    view: {
-      method: "GET",
-      outputValidator: responseRecordValidator
+  schema: {
+    id: {
+      type: "id",
+      primary: true,
+      required: true,
+      search: true,
+      storage: { column: "workspace_id" }
+    },
+    lightPrimaryColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_LIGHT_PALETTE.color,
+      storage: { column: "light_primary_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
     },
-    list: {
-      method: "GET",
-      outputValidator: createCursorListValidator(responseRecordValidator)
+    lightSecondaryColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_LIGHT_PALETTE.secondaryColor,
+      storage: { column: "light_secondary_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
     },
-    create: {
-      method: "POST",
-      bodyValidator: {
-        get schema() {
-          return buildCreateBodySchema();
-        },
-        normalize: normalizeInput
-      },
-      outputValidator: responseRecordValidator
+    lightSurfaceColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_LIGHT_PALETTE.surfaceColor,
+      storage: { column: "light_surface_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
     },
-    replace: {
-      method: "PUT",
-      bodyValidator: {
-        get schema() {
-          return buildCreateBodySchema();
-        },
-        normalize: normalizeInput
-      },
-      outputValidator: responseRecordValidator
+    lightSurfaceVariantColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_LIGHT_PALETTE.surfaceVariantColor,
+      storage: { column: "light_surface_variant_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
     },
-    patch: {
-      method: "PATCH",
-      bodyValidator: {
-        get schema() {
-          return Type.Partial(buildCreateBodySchema(), { additionalProperties: false });
-        },
-        normalize: normalizeInput
-      },
-      outputValidator: responseRecordValidator
+    darkPrimaryColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_DARK_PALETTE.color,
+      storage: { column: "dark_primary_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
+    },
+    darkSecondaryColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_DARK_PALETTE.secondaryColor,
+      storage: { column: "dark_secondary_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
+    },
+    darkSurfaceColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_DARK_PALETTE.surfaceColor,
+      storage: { column: "dark_surface_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
+    },
+    darkSurfaceVariantColor: {
+      type: "string",
+      required: true,
+      minLength: 7,
+      maxLength: 7,
+      defaultTo: DEFAULT_WORKSPACE_DARK_PALETTE.surfaceVariantColor,
+      storage: { column: "dark_surface_variant_color" },
+      setter: (value) => normalizeWorkspaceColorInput(value)
+    },
+    invitesEnabled: {
+      type: "boolean",
+      required: true,
+      defaultTo: true,
+      storage: { column: "invites_enabled" }
+    },
+    createdAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "created_at",
+        writeSerializer: "datetime-utc"
+      }
+    },
+    updatedAt: {
+      type: "dateTime",
+      default: "now()",
+      storage: {
+        column: "updated_at",
+        writeSerializer: "datetime-utc"
+      }
     }
+  },
+  messages: {
+    validation: "Fix invalid workspace settings values and try again.",
+    saveSuccess: "Workspace settings updated.",
+    saveError: "Unable to update workspace settings.",
+    apiValidation: "Validation failed."
+  },
+  crudOperations: ["view", "list", "create", "replace", "patch"],
+  crud: {
+    output: workspaceSettingsOutputSchema,
+    body: workspaceSettingsBodySchema
   }
-};
+});
 
-export { resource as workspaceSettingsResource };
+export {
+  WORKSPACE_SETTINGS_FIELD_KEYS,
+  workspaceSettingsOutputSchema,
+  workspaceSettingsResource
+};

package/test/repositoryContracts.test.js

@@ -17,13 +17,25 @@ function createKnexStub() {
   return knex;
 }
 
+function createApiStub() {
+  return {
+    resources: {
+      workspaceInvites: {},
+      workspaceMemberships: {},
+      workspaces: {},
+      workspaceSettings: {}
+    }
+  };
+}
+
 test("workspaces-core repositories expose withTransaction", async () => {
   const knex = createKnexStub();
+  const api = createApiStub();
   const repositories = [
-    createWorkspaceInvitesRepository(knex),
-    createWorkspaceMembershipsRepository(knex),
-    createWorkspacesRepository(knex),
-    createWorkspaceSettingsRepository(knex)
+    createWorkspaceInvitesRepository({ api, knex }),
+    createWorkspaceMembershipsRepository({ api, knex }),
+    createWorkspacesRepository({ api, knex }),
+    createWorkspaceSettingsRepository({ api, knex })
   ];
 
   for (const repository of repositories) {

package/test/resourcesCanonical.test.js

@@ -3,8 +3,10 @@ import assert from "node:assert/strict";
 import path from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import "../test-support/registerDefaultSettingsFields.js";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { workspaceMembersResource } from "../src/shared/resources/workspaceMembersResource.js";
+import { workspaceInvitesResource } from "../src/shared/resources/workspaceInvitesResource.js";
+import { workspaceMembershipsResource } from "../src/shared/resources/workspaceMembershipsResource.js";
 import { workspaceResource } from "../src/shared/resources/workspaceResource.js";
 import { workspaceSettingsResource } from "../src/shared/resources/workspaceSettingsResource.js";
 
@@ -28,13 +30,27 @@ function assertResourceOperationMessages(resource, operationName, label) {
 
 test("workspaces-core resources expose messages for all operations", () => {
   const resources = {
-    workspace: workspaceResource,
-    workspaceSettings: workspaceSettingsResource
+    workspace: {
+      resource: workspaceResource,
+      operations: ["view", "list", "create", "replace", "patch"]
+    },
+    workspaceSettings: {
+      resource: workspaceSettingsResource,
+      operations: ["view", "list", "create", "replace", "patch"]
+    },
+    workspaceMemberships: {
+      resource: workspaceMembershipsResource,
+      operations: ["view", "list", "create", "patch"]
+    },
+    workspaceInvites: {
+      resource: workspaceInvitesResource,
+      operations: ["view", "list", "create", "patch"]
+    }
   };
 
-  for (const [label, resource] of Object.entries(resources)) {
-    for (const operationName of ["view", "list", "create", "replace", "patch"]) {
-      assertResourceOperationMessages(resource, operationName, label);
+  for (const [label, spec] of Object.entries(resources)) {
+    for (const operationName of spec.operations) {
+      assertResourceOperationMessages(spec.resource, operationName, label);
     }
   }
 });
@@ -53,22 +69,29 @@ test("workspaces-core specialized resource operations expose messages and valida
 
   for (const { label, operation } of operationSpecs) {
     assert.equal(typeof operation?.messages, "object", `${label}.messages must be an object.`);
-    assert.equal(typeof operation?.outputValidator?.schema, "object", `${label}.outputValidator.schema must exist.`);
-    if (operation?.bodyValidator) {
-      assert.equal(typeof operation.bodyValidator.schema, "object", `${label}.bodyValidator.schema must exist.`);
+    assert.equal(
+      typeof resolveStructuredSchemaTransportSchema(operation?.output, {
+        context: `${label}.output`,
+        defaultMode: "replace"
+      }),
+      "object",
+      `${label}.output transport schema must exist.`
+    );
+    if (operation?.body) {
+      assert.equal(typeof operation.body.schema, "object", `${label}.body.schema must exist.`);
     }
-    if (operation?.paramsValidator) {
-      assert.equal(typeof operation.paramsValidator.schema, "object", `${label}.paramsValidator.schema must exist.`);
+    if (operation?.params) {
+      assert.equal(typeof operation.params.schema, "object", `${label}.params.schema must exist.`);
     }
-    if (operation?.queryValidator) {
-      assert.equal(typeof operation.queryValidator.schema, "object", `${label}.queryValidator.schema must exist.`);
+    if (operation?.query) {
+      assert.equal(typeof operation.query.schema, "object", `${label}.query.schema must exist.`);
     }
   }
 });
 
-test("workspaces-core no longer contains legacy shared/schema directory", () => {
+test("workspaces-core does not contain src/shared/schema", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
-  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+  const sharedSchemaDirPath = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(sharedSchemaDirPath), false, "src/shared/schema must not exist.");
 });

package/test/routeParamsValidator.test.js

@@ -1,36 +1,53 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Type } from "@fastify/type-provider-typebox";
+import { createSchema } from "json-rest-schema";
 import { compileRouteValidator } from "@jskit-ai/kernel/_testable";
 import { routeParamsValidator } from "../src/server/common/validators/routeParamsValidator.js";
 
-test("routeParamsValidator exposes a shared workspace route params validator", () => {
+function composeSchemaDefinition(...definitions) {
+  return Object.freeze({
+    schema: createSchema(
+      Object.assign({}, ...definitions.map((definition) => definition.schema.getFieldDefinitions()))
+    ),
+    mode: "patch"
+  });
+}
+
+test("routeParamsValidator exposes a shared workspace route params schema definition", () => {
   assert.equal(typeof routeParamsValidator.schema, "object");
-  assert.equal(typeof routeParamsValidator.normalize, "function");
+  assert.equal(routeParamsValidator.mode, "patch");
 });
 
-test("workspace route validator pipeline uses the shared params validator and merges query arrays automatically", () => {
+test("workspace route validator pipeline uses the shared params validator with a composed query schema", () => {
   const paginationQueryValidator = Object.freeze({
-    schema: Type.Object(
-      {
-        cursor: Type.Optional(Type.String({ minLength: 1 })),
-        limit: Type.Optional(Type.String({ pattern: "^[0-9]+$" }))
+    schema: createSchema({
+      cursor: {
+        type: "string",
+        required: false,
+        minLength: 1
       },
-      { additionalProperties: false }
-    )
+      limit: {
+        type: "string",
+        required: false,
+        pattern: "^[0-9]+$"
+      }
+    }),
+    mode: "patch"
   });
   const searchQueryValidator = Object.freeze({
-    schema: Type.Object(
-      {
-        search: Type.Optional(Type.String({ minLength: 1 }))
-      },
-      { additionalProperties: false }
-    )
+    schema: createSchema({
+      search: {
+        type: "string",
+        required: false,
+        minLength: 1
+      }
+    }),
+    mode: "patch"
   });
 
   const compiled = compileRouteValidator({
-    paramsValidator: routeParamsValidator,
-    queryValidator: [paginationQueryValidator, searchQueryValidator]
+    params: routeParamsValidator,
+    query: composeSchemaDefinition(paginationQueryValidator, searchQueryValidator)
   });
 
   assert.equal(compiled.schema.params.type, "object");
@@ -39,7 +56,8 @@ test("workspace route validator pipeline uses the shared params validator and me
   assert.equal(typeof compiled.schema.params.properties.memberUserId, "object");
   assert.equal(typeof compiled.schema.params.properties.inviteId, "object");
   assert.equal(typeof compiled.schema.params.properties.provider, "object");
-  assert.equal(compiled.input.params({ workspaceSlug: "  ACME  " }).workspaceSlug, "acme");
+  const normalizedParams = compiled.input.params({ workspaceSlug: "ACME" });
+  assert.equal(normalizedParams.workspaceSlug, "acme");
 
   assert.equal(compiled.schema.querystring.type, "object");
   assert.equal(compiled.schema.querystring.additionalProperties, false);