@topogram/cli 0.3.64 → 0.3.65

package/src/validator/projections/api-http-responses.js

@@ -0,0 +1,233 @@
+// @ts-check
+
+import {
+  blockSymbolItems,
+  getFieldValue,
+  pushError,
+  symbolValues
+} from "../utils.js";
+import { resolveCapabilityContractFields } from "./helpers.js";
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+export function validateProjectionHttpResponses(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const httpResponsesField = fieldMap.get("responses")?.[0];
+  if (!httpResponsesField || httpResponsesField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  for (const entry of httpResponsesField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const capabilityId = tokens[0];
+    const capability = registry.get(capabilityId);
+
+    if (!capability) {
+      pushError(errors, `Projection ${statement.id} responses references missing capability '${capabilityId}'`, entry.loc);
+      continue;
+    }
+    if (capability.kind !== "capability") {
+      pushError(errors, `Projection ${statement.id} responses must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
+    }
+    if (!realized.has(capabilityId)) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
+    }
+
+    const directives = parseProjectionHttpResponsesDirectives(tokens.slice(1));
+    for (const message of directives.errors) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' ${message}`, entry.loc);
+    }
+
+    if (!directives.mode) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'mode'`, entry.loc);
+    }
+
+    const mode = directives.mode;
+    if (mode && !["item", "collection", "paged", "cursor"].includes(mode)) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' has invalid mode '${mode}'`, entry.loc);
+    }
+
+    const itemShapeId = directives.item;
+    if (mode && mode !== "item" && !itemShapeId) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'item' for mode '${mode}'`, entry.loc);
+    }
+    if (itemShapeId) {
+      const itemShape = registry.get(itemShapeId);
+      if (!itemShape) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' references missing shape '${itemShapeId}'`, entry.loc);
+      } else if (itemShape.kind !== "shape") {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must reference a shape for 'item', found ${itemShape.kind} '${itemShape.id}'`, entry.loc);
+      }
+    }
+
+    if (mode === "cursor") {
+      if (!directives.cursor?.requestAfter) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'cursor request_after <field>'`, entry.loc);
+      }
+      if (!directives.cursor?.responseNext) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'cursor response_next <wire_name>'`, entry.loc);
+      }
+      if (!directives.limit) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'limit field <field> default <n> max <n>'`, entry.loc);
+      }
+      if (!directives.sort) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'sort by <field> direction <asc|desc>'`, entry.loc);
+      }
+    }
+
+    if (directives.sort && !["asc", "desc"].includes(directives.sort.direction || "")) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' has invalid sort direction '${directives.sort.direction}'`, entry.loc);
+    }
+
+    if (directives.total && !["true", "false"].includes(directives.total.included || "")) {
+      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' has invalid total included value '${directives.total.included}'`, entry.loc);
+    }
+
+    if (directives.limit) {
+      const defaultValue = Number.parseInt(directives.limit.defaultValue || "", 10);
+      const maxValue = Number.parseInt(directives.limit.maxValue || "", 10);
+      if (!Number.isInteger(defaultValue) || !Number.isInteger(maxValue)) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must use integer default/max values for 'limit'`, entry.loc);
+      } else if (defaultValue > maxValue) {
+        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must use default <= max for 'limit'`, entry.loc);
+      }
+    }
+
+    const inputFields = resolveCapabilityContractFields(registry, capabilityId, "input");
+    const outputFields = resolveCapabilityContractFields(registry, capabilityId, "output");
+    if (directives.cursor?.requestAfter && inputFields.size > 0 && !inputFields.has(directives.cursor.requestAfter)) {
+      pushError(errors, `Projection ${statement.id} responses references unknown input field '${directives.cursor.requestAfter}' for cursor request_after on ${capabilityId}`, entry.loc);
+    }
+    if (directives.limit?.field && inputFields.size > 0 && !inputFields.has(directives.limit.field)) {
+      pushError(errors, `Projection ${statement.id} responses references unknown input field '${directives.limit.field}' for limit on ${capabilityId}`, entry.loc);
+    }
+    if (directives.sort?.field && outputFields.size > 0 && !outputFields.has(directives.sort.field)) {
+      pushError(errors, `Projection ${statement.id} responses references unknown output field '${directives.sort.field}' for sort on ${capabilityId}`, entry.loc);
+    }
+  }
+}
+
+/**
+ * @param {string[]} tokens
+ * @returns {{
+ *   mode: string | null,
+ *   item: string | null,
+ *   cursor: { requestAfter: string | null, responseNext: string | null, responsePrev: string | null } | null,
+ *   limit: { field: string | null, defaultValue: string | null, maxValue: string | null } | null,
+ *   sort: { field: string | null, direction: string | null } | null,
+ *   total: { included: string | null } | null,
+ *   errors: string[]
+ * }}
+ */
+export function parseProjectionHttpResponsesDirectives(tokens) {
+  /** @type {{
+   *   mode: string | null,
+   *   item: string | null,
+   *   cursor: { requestAfter: string | null, responseNext: string | null, responsePrev: string | null } | null,
+   *   limit: { field: string | null, defaultValue: string | null, maxValue: string | null } | null,
+   *   sort: { field: string | null, direction: string | null } | null,
+   *   total: { included: string | null } | null,
+   *   errors: string[]
+   * }}
+   */
+  const result = {
+    mode: null,
+    item: null,
+    cursor: null,
+    limit: null,
+    sort: null,
+    total: null,
+    errors: []
+  };
+
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (token === "mode") {
+      result.mode = tokens[i + 1] || null;
+      if (!tokens[i + 1]) {
+        result.errors.push("is missing a value for 'mode'");
+      }
+      i += 1;
+      continue;
+    }
+    if (token === "item") {
+      result.item = tokens[i + 1] || null;
+      if (!tokens[i + 1]) {
+        result.errors.push("is missing a value for 'item'");
+      }
+      i += 1;
+      continue;
+    }
+    if (token === "cursor") {
+      const requestKeyword = tokens[i + 1];
+      const requestField = tokens[i + 2];
+      const responseKeyword = tokens[i + 3];
+      const responseNext = tokens[i + 4];
+      let responsePrev = null;
+      let consumed = 4;
+      if (tokens[i + 5] === "response_prev") {
+        responsePrev = tokens[i + 6] || null;
+        consumed = 6;
+      }
+      result.cursor = {
+        requestAfter: requestKeyword === "request_after" ? requestField : null,
+        responseNext: responseKeyword === "response_next" ? responseNext : null,
+        responsePrev
+      };
+      if (requestKeyword !== "request_after") {
+        result.errors.push("must use 'cursor request_after <field>'");
+      }
+      if (responseKeyword !== "response_next") {
+        result.errors.push("must use 'cursor response_next <wire_name>'");
+      }
+      i += consumed;
+      continue;
+    }
+    if (token === "limit") {
+      result.limit = {
+        field: tokens[i + 1] === "field" ? tokens[i + 2] || null : null,
+        defaultValue: tokens[i + 3] === "default" ? tokens[i + 4] || null : null,
+        maxValue: tokens[i + 5] === "max" ? tokens[i + 6] || null : null
+      };
+      if (tokens[i + 1] !== "field" || tokens[i + 3] !== "default" || tokens[i + 5] !== "max") {
+        result.errors.push("must use 'limit field <field> default <n> max <n>'");
+      }
+      i += 6;
+      continue;
+    }
+    if (token === "sort") {
+      result.sort = {
+        field: tokens[i + 1] === "by" ? tokens[i + 2] || null : null,
+        direction: tokens[i + 3] === "direction" ? tokens[i + 4] || null : null
+      };
+      if (tokens[i + 1] !== "by" || tokens[i + 3] !== "direction") {
+        result.errors.push("must use 'sort by <field> direction <asc|desc>'");
+      }
+      i += 4;
+      continue;
+    }
+    if (token === "total") {
+      result.total = {
+        included: tokens[i + 1] === "included" ? tokens[i + 2] || null : null
+      };
+      if (tokens[i + 1] !== "included") {
+        result.errors.push("must use 'total included <true|false>'");
+      }
+      i += 2;
+      continue;
+    }
+
+    result.errors.push(`has unknown directive '${token}'`);
+  }
+
+  return result;
+}

package/src/validator/projections/api-http.js

@@ -0,0 +1,44 @@
+// @ts-check
+
+import {
+  validateProjectionHttp,
+  validateProjectionHttpErrors,
+  validateProjectionHttpFields
+} from "./api-http-core.js";
+import { validateProjectionHttpResponses } from "./api-http-responses.js";
+import {
+  validateProjectionHttpPreconditions,
+  validateProjectionHttpIdempotency,
+  validateProjectionHttpCache,
+  validateProjectionHttpDelete
+} from "./api-http-policies.js";
+import {
+  validateProjectionHttpAsync,
+  validateProjectionHttpStatus,
+  validateProjectionHttpDownload,
+  validateProjectionHttpCallbacks
+} from "./api-http-async.js";
+import { validateProjectionHttpAuthz } from "./api-http-authz.js";
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+export function validateApiHttpProjection(errors, statement, fieldMap, registry) {
+  validateProjectionHttp(errors, statement, fieldMap, registry);
+  validateProjectionHttpErrors(errors, statement, fieldMap, registry);
+  validateProjectionHttpFields(errors, statement, fieldMap, registry);
+  validateProjectionHttpResponses(errors, statement, fieldMap, registry);
+  validateProjectionHttpPreconditions(errors, statement, fieldMap, registry);
+  validateProjectionHttpIdempotency(errors, statement, fieldMap, registry);
+  validateProjectionHttpCache(errors, statement, fieldMap, registry);
+  validateProjectionHttpDelete(errors, statement, fieldMap, registry);
+  validateProjectionHttpAsync(errors, statement, fieldMap, registry);
+  validateProjectionHttpStatus(errors, statement, fieldMap, registry);
+  validateProjectionHttpDownload(errors, statement, fieldMap, registry);
+  validateProjectionHttpAuthz(errors, statement, fieldMap, registry);
+  validateProjectionHttpCallbacks(errors, statement, fieldMap, registry);
+}

package/src/validator/projections/db.js

@@ -0,0 +1,353 @@
+// @ts-check
+
+import {
+  blockSymbolItems,
+  getFieldValue,
+  pushError,
+  symbolValues
+} from "../utils.js";
+import { statementFieldNames } from "../model-helpers.js";
+import { parseUiDirectiveMap } from "./helpers.js";
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+function validateProjectionDbTables(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const dbTablesField = fieldMap.get("tables")?.[0];
+  if (!dbTablesField || dbTablesField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  const seenTables = new Set();
+  for (const entry of dbTablesField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [entityId, tableKeyword, tableName] = tokens;
+    const entity = registry.get(entityId);
+
+    if (!entity) {
+      pushError(errors, `Projection ${statement.id} tables references missing entity '${entityId}'`, entry.loc);
+      continue;
+    }
+    if (entity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} tables must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
+    }
+    if (!realized.has(entityId)) {
+      pushError(errors, `Projection ${statement.id} tables entity '${entityId}' must also appear in 'realizes'`, entry.loc);
+    }
+    if (tableKeyword !== "table") {
+      pushError(errors, `Projection ${statement.id} tables for '${entityId}' must use 'table'`, entry.loc);
+    }
+    if (!tableName) {
+      pushError(errors, `Projection ${statement.id} tables for '${entityId}' must include a table name`, entry.loc);
+    } else if (seenTables.has(tableName)) {
+      pushError(errors, `Projection ${statement.id} tables has duplicate table name '${tableName}'`, entry.loc);
+    }
+    seenTables.add(tableName);
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+function validateProjectionDbColumns(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const dbColumnsField = fieldMap.get("columns")?.[0];
+  if (!dbColumnsField || dbColumnsField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  for (const entry of dbColumnsField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [entityId, fieldKeyword, fieldName, columnKeyword, columnName] = tokens;
+    const entity = registry.get(entityId);
+
+    if (!entity) {
+      pushError(errors, `Projection ${statement.id} columns references missing entity '${entityId}'`, entry.loc);
+      continue;
+    }
+    if (entity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} columns must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
+    }
+    if (!realized.has(entityId)) {
+      pushError(errors, `Projection ${statement.id} columns entity '${entityId}' must also appear in 'realizes'`, entry.loc);
+    }
+    if (fieldKeyword !== "field") {
+      pushError(errors, `Projection ${statement.id} columns for '${entityId}' must use 'field'`, entry.loc);
+    }
+    if (columnKeyword !== "column") {
+      pushError(errors, `Projection ${statement.id} columns for '${entityId}' must use 'column'`, entry.loc);
+    }
+    const entityFieldNames = new Set(statementFieldNames(entity));
+    if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
+      pushError(errors, `Projection ${statement.id} columns references unknown field '${fieldName}' on ${entityId}`, entry.loc);
+    }
+    if (!columnName) {
+      pushError(errors, `Projection ${statement.id} columns for '${entityId}.${fieldName}' must include a column name`, entry.loc);
+    }
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+function validateProjectionDbKeys(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const dbKeysField = fieldMap.get("keys")?.[0];
+  if (!dbKeysField || dbKeysField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  for (const entry of dbKeysField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [entityId, keyType] = tokens;
+    const entity = registry.get(entityId);
+
+    if (!entity) {
+      pushError(errors, `Projection ${statement.id} keys references missing entity '${entityId}'`, entry.loc);
+      continue;
+    }
+    if (entity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} keys must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
+    }
+    if (!realized.has(entityId)) {
+      pushError(errors, `Projection ${statement.id} keys entity '${entityId}' must also appear in 'realizes'`, entry.loc);
+    }
+    if (!["primary", "unique"].includes(keyType || "")) {
+      pushError(errors, `Projection ${statement.id} keys for '${entityId}' has invalid key type '${keyType}'`, entry.loc);
+    }
+    const fieldList = entry.items[2];
+    if (!fieldList || fieldList.type !== "list" || fieldList.items.length === 0) {
+      pushError(errors, `Projection ${statement.id} keys for '${entityId}' must include a non-empty field list`, entry.loc);
+      continue;
+    }
+    const entityFieldNames = new Set(statementFieldNames(entity));
+    for (const item of fieldList.items) {
+      if (item.type === "symbol" && entityFieldNames.size > 0 && !entityFieldNames.has(item.value)) {
+        pushError(errors, `Projection ${statement.id} keys references unknown field '${item.value}' on ${entityId}`, item.loc);
+      }
+    }
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+function validateProjectionDbIndexes(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const dbIndexesField = fieldMap.get("indexes")?.[0];
+  if (!dbIndexesField || dbIndexesField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  for (const entry of dbIndexesField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [entityId, indexType] = tokens;
+    const entity = registry.get(entityId);
+
+    if (!entity) {
+      pushError(errors, `Projection ${statement.id} indexes references missing entity '${entityId}'`, entry.loc);
+      continue;
+    }
+    if (entity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} indexes must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
+    }
+    if (!realized.has(entityId)) {
+      pushError(errors, `Projection ${statement.id} indexes entity '${entityId}' must also appear in 'realizes'`, entry.loc);
+    }
+    if (!["index", "unique"].includes(indexType || "")) {
+      pushError(errors, `Projection ${statement.id} indexes for '${entityId}' has invalid index type '${indexType}'`, entry.loc);
+    }
+    const fieldList = entry.items[2];
+    if (!fieldList || fieldList.type !== "list" || fieldList.items.length === 0) {
+      pushError(errors, `Projection ${statement.id} indexes for '${entityId}' must include a non-empty field list`, entry.loc);
+      continue;
+    }
+    const entityFieldNames = new Set(statementFieldNames(entity));
+    for (const item of fieldList.items) {
+      if (item.type === "symbol" && entityFieldNames.size > 0 && !entityFieldNames.has(item.value)) {
+        pushError(errors, `Projection ${statement.id} indexes references unknown field '${item.value}' on ${entityId}`, item.loc);
+      }
+    }
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+function validateProjectionDbRelations(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const dbRelationsField = fieldMap.get("relations")?.[0];
+  if (!dbRelationsField || dbRelationsField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  for (const entry of dbRelationsField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [entityId, relationType, fieldName, referencesKeyword, targetRef, onDeleteKeyword, onDeleteValue] = tokens;
+    const entity = registry.get(entityId);
+
+    if (!entity) {
+      pushError(errors, `Projection ${statement.id} relations references missing entity '${entityId}'`, entry.loc);
+      continue;
+    }
+    if (entity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} relations must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
+    }
+    if (!realized.has(entityId)) {
+      pushError(errors, `Projection ${statement.id} relations entity '${entityId}' must also appear in 'realizes'`, entry.loc);
+    }
+    if (relationType !== "foreign_key") {
+      pushError(errors, `Projection ${statement.id} relations for '${entityId}' must use 'foreign_key'`, entry.loc);
+    }
+    if (referencesKeyword !== "references") {
+      pushError(errors, `Projection ${statement.id} relations for '${entityId}' must use 'references'`, entry.loc);
+    }
+    if (onDeleteKeyword && onDeleteKeyword !== "on_delete") {
+      pushError(errors, `Projection ${statement.id} relations for '${entityId}' has unexpected token '${onDeleteKeyword}'`, entry.loc);
+    }
+    if (onDeleteValue && !["cascade", "restrict", "set_null", "no_action"].includes(onDeleteValue)) {
+      pushError(errors, `Projection ${statement.id} relations for '${entityId}' has invalid on_delete '${onDeleteValue}'`, entry.loc);
+    }
+    const entityFieldNames = new Set(statementFieldNames(entity));
+    if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
+      pushError(errors, `Projection ${statement.id} relations references unknown field '${fieldName}' on ${entityId}`, entry.loc);
+    }
+    const [targetEntityId, targetFieldName] = (targetRef || "").split(".");
+    const targetEntity = registry.get(targetEntityId);
+    if (!targetEntity) {
+      pushError(errors, `Projection ${statement.id} relations references missing target entity '${targetEntityId}'`, entry.loc);
+      continue;
+    }
+    if (targetEntity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} relations must reference an entity target, found ${targetEntity.kind} '${targetEntity.id}'`, entry.loc);
+    }
+    const targetFieldNames = new Set(statementFieldNames(targetEntity));
+    if (targetFieldName && targetFieldNames.size > 0 && !targetFieldNames.has(targetFieldName)) {
+      pushError(errors, `Projection ${statement.id} relations references unknown target field '${targetFieldName}' on ${targetEntityId}`, entry.loc);
+    }
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+function validateProjectionDbLifecycle(errors, statement, fieldMap, registry) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const dbLifecycleField = fieldMap.get("lifecycle")?.[0];
+  if (!dbLifecycleField || dbLifecycleField.value.type !== "block") {
+    return;
+  }
+
+  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
+  for (const entry of dbLifecycleField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [entityId, lifecycleType] = tokens;
+    const entity = registry.get(entityId);
+
+    if (!entity) {
+      pushError(errors, `Projection ${statement.id} lifecycle references missing entity '${entityId}'`, entry.loc);
+      continue;
+    }
+    if (entity.kind !== "entity") {
+      pushError(errors, `Projection ${statement.id} lifecycle must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
+    }
+    if (!realized.has(entityId)) {
+      pushError(errors, `Projection ${statement.id} lifecycle entity '${entityId}' must also appear in 'realizes'`, entry.loc);
+    }
+
+    const directives = parseUiDirectiveMap(tokens, 2, errors, statement, entry, `lifecycle for '${entityId}'`);
+    if (!["soft_delete", "timestamps"].includes(lifecycleType || "")) {
+      pushError(errors, `Projection ${statement.id} lifecycle for '${entityId}' has invalid lifecycle '${lifecycleType}'`, entry.loc);
+      continue;
+    }
+
+    const entityFieldNames = new Set(statementFieldNames(entity));
+    if (lifecycleType === "soft_delete") {
+      for (const requiredKey of ["field", "value"]) {
+        if (!directives.has(requiredKey)) {
+          pushError(errors, `Projection ${statement.id} lifecycle for '${entityId}' must include '${requiredKey}' for soft_delete`, entry.loc);
+        }
+      }
+      const fieldName = directives.get("field");
+      if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
+        pushError(errors, `Projection ${statement.id} lifecycle references unknown field '${fieldName}' on ${entityId}`, entry.loc);
+      }
+    }
+
+    if (lifecycleType === "timestamps") {
+      for (const requiredKey of ["created_at", "updated_at"]) {
+        if (!directives.has(requiredKey)) {
+          pushError(errors, `Projection ${statement.id} lifecycle for '${entityId}' must include '${requiredKey}' for timestamps`, entry.loc);
+        }
+        const fieldName = directives.get(requiredKey);
+        if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
+          pushError(errors, `Projection ${statement.id} lifecycle references unknown field '${fieldName}' on ${entityId}`, entry.loc);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @param {TopogramRegistry} registry
+ * @returns {void}
+ */
+export function validateDbProjection(errors, statement, fieldMap, registry) {
+  validateProjectionDbTables(errors, statement, fieldMap, registry);
+  validateProjectionDbColumns(errors, statement, fieldMap, registry);
+  validateProjectionDbKeys(errors, statement, fieldMap, registry);
+  validateProjectionDbIndexes(errors, statement, fieldMap, registry);
+  validateProjectionDbRelations(errors, statement, fieldMap, registry);
+  validateProjectionDbLifecycle(errors, statement, fieldMap, registry);
+}

package/src/validator/projections/generator-defaults.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+import {
+  blockSymbolItems,
+  pushError
+} from "../utils.js";
+
+/**
+ * @param {ValidationErrors} errors
+ * @param {TopogramStatement} statement
+ * @param {TopogramFieldMap} fieldMap
+ * @returns {void}
+ */
+export function validateProjectionGeneratorDefaults(errors, statement, fieldMap) {
+  if (statement.kind !== "projection") {
+    return;
+  }
+
+  const generatorField = fieldMap.get("generator_defaults")?.[0];
+  if (!generatorField || generatorField.value.type !== "block") {
+    return;
+  }
+
+  for (const entry of generatorField.value.entries) {
+    const tokens = blockSymbolItems(entry).map((item) => item.value);
+    const [key, value] = tokens;
+    if (!["profile", "language", "styling"].includes(key || "")) {
+      pushError(errors, `Projection ${statement.id} generator_defaults has unknown key '${key}'`, entry.loc);
+      continue;
+    }
+    if (!value) {
+      pushError(errors, `Projection ${statement.id} generator_defaults is missing a value for '${key}'`, entry.loc);
+      continue;
+    }
+    if (key === "profile" && !["vanilla", "sveltekit", "react", "swiftui", "postgres_sql", "sqlite_sql", "prisma", "drizzle"].includes(value)) {
+      pushError(errors, `Projection ${statement.id} generator_defaults has unsupported profile '${value}'`, entry.loc);
+    }
+    if (key === "language" && !["typescript", "javascript", "swift", "sql"].includes(value)) {
+      pushError(errors, `Projection ${statement.id} generator_defaults has unsupported language '${value}'`, entry.loc);
+    }
+    if (key === "styling" && !["tailwind", "css"].includes(value)) {
+      pushError(errors, `Projection ${statement.id} generator_defaults has unsupported styling '${value}'`, entry.loc);
+    }
+  }
+}