@eide/foir-cli 0.4.11 → 0.5.0

package/dist/cli.js

@@ -3146,10 +3146,13 @@ async function createPlatformClient(options) {
     headers["Authorization"] = `Bearer ${credentials.accessToken}`;
   }
   const resolved = await resolveProjectContext(options);
-  if (resolved) {
-    headers["x-tenant-id"] = resolved.project.tenantId;
-    headers["x-project-id"] = resolved.project.id;
+  if (!resolved) {
+    throw new Error(
+      "No project selected. Run `foir select-project` to choose a project."
+    );
   }
+  headers["x-tenant-id"] = resolved.project.tenantId;
+  headers["x-project-id"] = resolved.project.id;
   const authInterceptor = (next) => async (req) => {
     for (const [key, value] of Object.entries(headers)) {
       req.header.set(key, value);
@@ -3240,10 +3243,13 @@ async function getStorageAuth(options) {
     baseHeaders["Authorization"] = `Bearer ${credentials.accessToken}`;
   }
   const resolved = await resolveProjectContext(options);
-  if (resolved) {
-    baseHeaders["x-tenant-id"] = resolved.project.tenantId;
-    baseHeaders["x-project-id"] = resolved.project.id;
+  if (!resolved) {
+    throw new Error(
+      "No project selected. Run `foir select-project` to choose a project."
+    );
   }
+  baseHeaders["x-tenant-id"] = resolved.project.tenantId;
+  baseHeaders["x-project-id"] = resolved.project.id;
   let cachedToken = null;
   const getToken = async () => {
     if (cachedToken && Date.now() < cachedToken.expiresAt - 3e4) {
@@ -5105,6 +5111,275 @@ async function reconcileApiKeys(client, apiKeys, summary) {
   }
 }
 
+// src/lib/validate-integrations.ts
+import { fromJson as fromJson3 } from "@bufbuild/protobuf";
+import { pathToString } from "@bufbuild/protobuf/reflect";
+import { createValidator } from "@bufbuild/protovalidate";
+import {
+  IntegrationConfigSchema,
+  ExtensionConfigSchema
+} from "@eide/foir-proto-ts/integrations/v1/integrations_pb";
+var IntegrationValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super(
+      `foir.config.ts failed validation:
+${errors.map((e) => `  - ${e}`).join("\n")}`
+    );
+    this.name = "IntegrationValidationError";
+    this.errors = errors;
+  }
+};
+var validator = createValidator();
+function validateIntegrationsAndExtensions(manifest) {
+  const errors = [];
+  const warnings = [];
+  const modelsByKey = /* @__PURE__ */ new Map();
+  for (const model of manifest.models ?? []) {
+    modelsByKey.set(model.key, model);
+  }
+  if (manifest.integrations) {
+    for (const [name, integration] of Object.entries(manifest.integrations)) {
+      validateIntegration(name, integration, modelsByKey, errors, warnings);
+    }
+  }
+  if (manifest.extensions) {
+    for (const [name, extension] of Object.entries(manifest.extensions)) {
+      validateExtension(name, extension, modelsByKey, errors);
+    }
+  }
+  return { errors, warnings };
+}
+function assertValid(result) {
+  if (result.errors.length > 0) {
+    throw new IntegrationValidationError(result.errors);
+  }
+}
+function validateIntegration(name, integration, modelsByKey, errors, warnings) {
+  const prefix = `integration '${name}'`;
+  const protoJson = toIntegrationProtoJson(name, integration);
+  const structuralErrors = runProtoValidation(
+    prefix,
+    protoJson,
+    (json) => fromJson3(IntegrationConfigSchema, json, { ignoreUnknownFields: true })
+  );
+  errors.push(...structuralErrors);
+  const sync = integration.sync ?? {};
+  for (const [sourceType, mapping] of Object.entries(sync)) {
+    validateSyncMapping(
+      `${prefix} sync.${sourceType}`,
+      mapping,
+      name,
+      modelsByKey,
+      errors,
+      warnings
+    );
+  }
+}
+function validateSyncMapping(prefix, mapping, integrationName, modelsByKey, errors, warnings) {
+  const model = mapping.model ? modelsByKey.get(mapping.model) : void 0;
+  const seed = mapping.modelSeed;
+  if (!mapping.model) {
+    return;
+  }
+  if (!model && !seed) {
+    errors.push(
+      `${prefix}: missing model '${mapping.model}' referenced by integration '${integrationName}' \u2014 declare it under models or provide a modelSeed`
+    );
+    return;
+  }
+  const fieldKeys = model ? new Set((model.fields ?? []).map((f) => f.key)) : new Set(Object.keys(seed?.fields ?? {}));
+  if (mapping.naturalKey && !fieldKeys.has(mapping.naturalKey)) {
+    errors.push(
+      `${prefix}: naturalKey '${mapping.naturalKey}' does not exist on ${model ? `model '${mapping.model}'` : `modelSeed for '${mapping.model}'`}`
+    );
+  }
+  const fields = mapping.fields ?? {};
+  for (const [sourceField, foirField] of Object.entries(fields)) {
+    if (!foirField) continue;
+    if (!fieldKeys.has(foirField)) {
+      errors.push(
+        `${prefix}: field mapping '${sourceField} -> ${foirField}' references field '${foirField}' which does not exist on ${model ? `model '${mapping.model}'` : `modelSeed for '${mapping.model}'`}`
+      );
+    }
+  }
+  if (seed && model) {
+    detectSeedDrift(prefix, seed, model, warnings);
+  }
+}
+function detectSeedDrift(prefix, seed, model, warnings) {
+  const modelFieldTypes = /* @__PURE__ */ new Map();
+  for (const field of model.fields ?? []) {
+    modelFieldTypes.set(field.key, field.type);
+  }
+  for (const [key, field] of Object.entries(seed.fields ?? {})) {
+    const modelType = modelFieldTypes.get(key);
+    if (!modelType) {
+      warnings.push(
+        `${prefix}: modelSeed.fields.${key} is not present on existing model \u2014 modelSeed is ignored on subsequent pushes`
+      );
+    } else if (field.type && modelType !== field.type) {
+      warnings.push(
+        `${prefix}: modelSeed.fields.${key}.type '${field.type}' disagrees with existing model field type '${modelType}' \u2014 modelSeed is ignored on subsequent pushes`
+      );
+    }
+  }
+}
+function validateExtension(name, extension, modelsByKey, errors) {
+  const prefix = `extension '${name}'`;
+  const protoJson = toExtensionProtoJson(name, extension);
+  const structuralErrors = runProtoValidation(
+    prefix,
+    protoJson,
+    (json) => fromJson3(ExtensionConfigSchema, json, { ignoreUnknownFields: true })
+  );
+  errors.push(...structuralErrors);
+  const placements = extension.placements ?? [];
+  placements.forEach((placement, index) => {
+    if (placement.model && !modelsByKey.has(placement.model)) {
+      errors.push(
+        `${prefix} placements[${index}]: missing model '${placement.model}' referenced by extension '${name}'`
+      );
+    }
+  });
+}
+function runProtoValidation(prefix, json, decode) {
+  let message;
+  try {
+    message = decode(json);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [`${prefix}: cannot decode as proto \u2014 ${msg}`];
+  }
+  const result = runValidate(message);
+  if (result.kind === "valid") return [];
+  if (result.kind === "error") {
+    return [`${prefix}: validator error \u2014 ${result.error.message}`];
+  }
+  return result.violations.map((v) => `${prefix}: ${formatViolation(v)}`);
+}
+function runValidate(message) {
+  if (!message || typeof message !== "object") {
+    return { kind: "error", error: new Error("message is not an object") };
+  }
+  const anyMsg = message;
+  let schema;
+  if (anyMsg.$typeName === "integrations.v1.IntegrationConfig") {
+    schema = IntegrationConfigSchema;
+  } else if (anyMsg.$typeName === "integrations.v1.ExtensionConfig") {
+    schema = ExtensionConfigSchema;
+  } else {
+    return { kind: "error", error: new Error(`unknown message type ${anyMsg.$typeName ?? "?"}`) };
+  }
+  const result = validator.validate(
+    // Both schema/message casts are safe because we picked schema by $typeName.
+    schema,
+    message
+  );
+  if (result.kind === "valid") return { kind: "valid" };
+  if (result.kind === "error") return { kind: "error", error: result.error };
+  return { kind: "invalid", violations: result.violations };
+}
+function formatViolation(v) {
+  let path3 = "";
+  try {
+    path3 = pathToString(v.field);
+  } catch {
+    path3 = "";
+  }
+  const message = v.message ?? "";
+  return path3 ? `${path3}: ${message}` : message;
+}
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function toIntegrationProtoJson(name, integration) {
+  return compact({
+    name,
+    enabled: integration.enabled ?? true,
+    middleware: integration.middleware ? { url: integration.middleware.url ?? "" } : void 0,
+    credentials: {
+      strategy: integration.credentials?.strategy ? credentialStrategyToProto(integration.credentials.strategy) : "CREDENTIAL_STRATEGY_UNSPECIFIED"
+    },
+    sync: integration.sync ? Object.fromEntries(
+      Object.entries(integration.sync).map(([k, v]) => [k, syncMappingToProto(v)])
+    ) : {},
+    settings: integration.settings,
+    metadata: integration.metadata
+  });
+}
+function syncMappingToProto(mapping) {
+  return compact({
+    model: mapping.model ?? "",
+    naturalKey: mapping.naturalKey ?? "",
+    fields: mapping.fields ?? {},
+    modelSeed: mapping.modelSeed ? {
+      fields: Object.fromEntries(
+        Object.entries(mapping.modelSeed.fields ?? {}).map(([k, v]) => [
+          k,
+          compact({
+            type: v.type ?? "",
+            required: v.required ?? false,
+            naturalKey: v.naturalKey ?? false,
+            label: v.label,
+            helpText: v.helpText,
+            config: v.config
+          })
+        ])
+      )
+    } : void 0
+  });
+}
+function credentialStrategyToProto(strategy) {
+  switch (strategy) {
+    case "oauth":
+      return "CREDENTIAL_STRATEGY_OAUTH";
+    case "api_key":
+      return "CREDENTIAL_STRATEGY_API_KEY";
+    case "shared_secret":
+      return "CREDENTIAL_STRATEGY_SHARED_SECRET";
+    case "ssh_key":
+      return "CREDENTIAL_STRATEGY_SSH_KEY";
+    case "none":
+      return "CREDENTIAL_STRATEGY_NONE";
+    case "managed":
+      return "CREDENTIAL_STRATEGY_MANAGED";
+    default:
+      return "CREDENTIAL_STRATEGY_UNSPECIFIED";
+  }
+}
+function toExtensionProtoJson(name, extension) {
+  const placements = (extension.placements ?? []).map(
+    (p) => compact({
+      target: extensionTargetToProto(p.target),
+      model: p.model ?? "",
+      tab: p.tab ?? "",
+      title: p.title ?? "",
+      hints: p.hints
+    })
+  );
+  return compact({
+    name,
+    url: extension.url ?? "",
+    placements,
+    metadata: extension.metadata
+  });
+}
+function extensionTargetToProto(target) {
+  switch (target) {
+    case "record":
+      return "EXTENSION_TARGET_RECORD";
+    case "model-list":
+      return "EXTENSION_TARGET_MODEL_LIST";
+    default:
+      return "EXTENSION_TARGET_UNSPECIFIED";
+  }
+}
+
 // src/commands/push.ts
 var CONFIG_FILE_NAMES = [
   "foir.config.ts",
@@ -5181,6 +5456,11 @@ function registerPushCommand(program2, globalOpts) {
             'Config must have at least "key" and "name" fields.'
           );
         }
+        const validation = validateIntegrationsAndExtensions(config2);
+        for (const warning of validation.warnings) {
+          console.log(chalk6.yellow(`\u26A0 ${warning}`));
+        }
+        assertValid(validation);
         const client = await createPlatformClient(globalOpts());
         console.log(
           chalk6.dim(`Pushing config "${config2.key}" to platform...`)

package/dist/lib/config-helpers.d.ts

@@ -166,6 +166,57 @@ interface ApplyConfigApiKeyInput {
     /** Restrict file uploads to specific MIME types (e.g. ["image/*", "video/*"]). */
     allowedFileTypes?: string[];
 }
+type CredentialStrategy = 'oauth' | 'api_key' | 'shared_secret' | 'ssh_key' | 'none' | 'managed';
+interface IntegrationMiddlewareInput {
+    /** Full https URL of the middleware handling this integration. */
+    url: string;
+}
+interface IntegrationCredentialsInput {
+    strategy: CredentialStrategy;
+}
+interface ModelSeedFieldInput {
+    type: string;
+    required?: boolean;
+    naturalKey?: boolean;
+    label?: string;
+    helpText?: string;
+    config?: Record<string, unknown>;
+}
+interface ModelSeedInput {
+    fields: Record<string, ModelSeedFieldInput>;
+}
+interface IntegrationSyncMappingInput {
+    /** foir model key this source type writes into. */
+    model: string;
+    /** foir field holding the upstream natural key. UPSERTs are keyed on this. */
+    naturalKey: string;
+    /** Explicit source field -> foir field mapping. */
+    fields: Record<string, string>;
+    /** Optional one-time bootstrap schema if the target model is missing. */
+    modelSeed?: ModelSeedInput;
+}
+interface IntegrationInput {
+    enabled?: boolean;
+    middleware: IntegrationMiddlewareInput;
+    credentials: IntegrationCredentialsInput;
+    sync: Record<string, IntegrationSyncMappingInput>;
+    /** Opaque middleware-specific settings — not validated by the CLI. */
+    settings?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+type ExtensionTarget = 'record' | 'model-list';
+interface ExtensionPlacementInput {
+    target: ExtensionTarget;
+    model: string;
+    tab: string;
+    title: string;
+    hints?: Record<string, unknown>;
+}
+interface ExtensionInput {
+    url: string;
+    placements: ExtensionPlacementInput[];
+    metadata?: Record<string, unknown>;
+}
 interface ApplyConfigInput {
     key: string;
     name: string;
@@ -181,6 +232,10 @@ interface ApplyConfigInput {
     authProviders?: ApplyConfigAuthProviderInput[];
     placements?: ApplyConfigPlacementInput[];
     apiKeys?: ApplyConfigApiKeyInput[];
+    /** Per-project integration declarations, keyed by integration name. */
+    integrations?: Record<string, IntegrationInput>;
+    /** Per-project extension declarations, keyed by extension name. */
+    extensions?: Record<string, ExtensionInput>;
     [key: string]: unknown;
 }
 /** Define a complete config manifest. */
@@ -203,5 +258,9 @@ declare function defineAuthProvider(provider: ApplyConfigAuthProviderInput): App
 declare function defineHook(hook: ApplyConfigHookInput): ApplyConfigHookInput;
 /** Define an editor placement (sidebar or main-editor tab). */
 declare function definePlacement(placement: ApplyConfigPlacementInput): ApplyConfigPlacementInput;
+/** Define an integration declaration. */
+declare function defineIntegration(integration: IntegrationInput): IntegrationInput;
+/** Define an extension declaration. */
+declare function defineExtensionDeclaration(extension: ExtensionInput): ExtensionInput;
 
-export { type ApplyConfigApiKeyInput, type ApplyConfigAuthProviderInput, type ApplyConfigHookInput, type ApplyConfigInput, type ApplyConfigModelInput, type ApplyConfigOperationInput, type ApplyConfigPlacementInput, type ApplyConfigScheduleInput, type ApplyConfigSegmentInput, type ExpressionPrecondition, type FieldDefinitionInput, type Precondition, type QuotaRule, type SegmentPrecondition, defineAuthProvider, defineConfig, defineExtension, defineField, defineHook, defineModel, defineOperation, definePlacement, defineSchedule, defineSegment };
+export { type ApplyConfigApiKeyInput, type ApplyConfigAuthProviderInput, type ApplyConfigHookInput, type ApplyConfigInput, type ApplyConfigModelInput, type ApplyConfigOperationInput, type ApplyConfigPlacementInput, type ApplyConfigScheduleInput, type ApplyConfigSegmentInput, type CredentialStrategy, type ExpressionPrecondition, type ExtensionInput, type ExtensionPlacementInput, type ExtensionTarget, type FieldDefinitionInput, type IntegrationCredentialsInput, type IntegrationInput, type IntegrationMiddlewareInput, type IntegrationSyncMappingInput, type ModelSeedFieldInput, type ModelSeedInput, type Precondition, type QuotaRule, type SegmentPrecondition, defineAuthProvider, defineConfig, defineExtension, defineExtensionDeclaration, defineField, defineHook, defineIntegration, defineModel, defineOperation, definePlacement, defineSchedule, defineSegment };

package/dist/lib/config-helpers.js

@@ -27,12 +27,20 @@ function defineHook(hook) {
 function definePlacement(placement) {
   return placement;
 }
+function defineIntegration(integration) {
+  return integration;
+}
+function defineExtensionDeclaration(extension) {
+  return extension;
+}
 export {
   defineAuthProvider,
   defineConfig,
   defineExtension,
+  defineExtensionDeclaration,
   defineField,
   defineHook,
+  defineIntegration,
   defineModel,
   defineOperation,
   definePlacement,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eide/foir-cli",
-  "version": "0.4.11",
+  "version": "0.5.0",
   "description": "Universal platform CLI for Foir platform",
   "type": "module",
   "publishConfig": {
@@ -47,9 +47,10 @@
   "license": "UNLICENSED",
   "dependencies": {
     "@bufbuild/protobuf": "^2.0.0",
+    "@bufbuild/protovalidate": "^1.1.1",
     "@connectrpc/connect": "^2.0.0",
     "@connectrpc/connect-node": "^2.0.0",
-    "@eide/foir-proto-ts": "^0.3.8",
+    "@eide/foir-proto-ts": "^0.6.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",