bazis 0.96.1

package/library/orm/index.ts

@@ -0,0 +1,162 @@
+// Entity metadata and configuration
+export {
+  Column,
+  Check,
+  CreatedAt,
+  Entity,
+  ForeignKey,
+  HasConversion,
+  Index,
+  Key,
+  ManyToOne,
+  OneToMany,
+  QueryFilter,
+  Required,
+  Schema,
+  SoftDelete,
+  UpdatedAt,
+  UUID,
+} from "./Metadata/decorators";
+export type {
+  ColumnOptions,
+  ColumnDefaultValue,
+  EntityOptions,
+  IndexOptions,
+  KeyOptions,
+  RelationOptions,
+  UUIDOptions,
+  ReferentialAction,
+} from "./Metadata/decorators";
+export { OrmModel } from "./Metadata/OrmModel";
+export { ModelBuilder } from "./Metadata/ModelBuilder";
+export { KeyTuple } from "./Metadata/KeyTuple";
+export {
+  buildDynamicModel,
+  type DynamicFieldDefinition,
+  type DynamicEntityDefinition,
+  type DynamicPrimaryKeyDefinition,
+  type DynamicForeignKeyDefinition,
+  type DynamicCheckDefinition,
+  type DynamicIndexDefinition,
+  type DynamicRelationDefinition,
+  type DynamicTableDefinition,
+  type DynamicTargetResolver,
+  type LogicalFieldType,
+  type ScalarLogicalFieldType,
+} from "./Metadata/DynamicModelBuilder";
+export { pluralize } from "./Metadata/conventions";
+export { ValueConverters, type ValueConverter } from "./Metadata/ValueConverter";
+export type {
+  ColumnOptionsType,
+  ColumnType,
+  EntityModel,
+  ForeignKeyModel,
+  IndexModel,
+  CheckModel,
+  KeyGeneration,
+  PropertyConvention,
+  PropertyModel,
+  RelationKind,
+  RelationModel,
+  SemanticColumnType,
+  StorageColumnType,
+} from "./Metadata/types";
+
+// Context (the pure engine; the DI wiring is in `@/core/orm`)
+export { DbContext } from "./DbContext";
+export { DbContextOptions, type DbContextOptionsConfig } from "./DbContextOptions";
+export { DbContextFactory } from "./DbContextFactory";
+export { DatabaseFacade } from "./DatabaseFacade";
+export { OrmTransaction } from "./Transactions/OrmTransaction";
+export type { OrmDatabaseTimeV1, OrmTransactionScopeOptions } from "./Transactions/OrmTransaction";
+
+// Repository (the implementation; the `IRepository<T>` contract and tokens are in `@/core/orm`)
+export { Repository } from "./Repository/Repository";
+
+// Queries
+export { DbSet } from "./Query/DbSet";
+export { EntityQuery, IncludableQuery, ProjectedQuery, type NavigationElement } from "./Query/EntityQuery";
+export type { ForUpdateOptionsV1 } from "./Query/EntityQuery";
+export type { OrmMutationResultV1, OrmInsertIfAbsentResultV1, OrmUpdateValuesV1, OrmUniqueKeySelectorV1 } from "./Query/ImmediateMutations";
+export { Operand, Predicate } from "./Query/conditions";
+export type { FieldSelector, KeySelectorFn, PredicateFn } from "./Query/conditions";
+
+// Tracking
+export { ChangeTracker, type TrackedEntry } from "./Tracking/ChangeTracker";
+export { EntityState } from "./Tracking/EntityState";
+export {
+  ExecutionStrategy,
+  withRetry,
+  withoutExecutionStrategyRetries,
+  type ExecutionStrategyOptions,
+} from "./Saving/ExecutionStrategy";
+
+// Providers (connection values: `postgres(...)`).
+export { PostgresProvider, postgres, type PostgresProviderOptions, type PostgresServerTimeouts, type PostgresOperationEvent } from "./Providers/PostgresProvider";
+export { PostgresDialect } from "./Providers/PostgresDialect";
+export type {
+  AfterCommitCallback,
+  DatabaseProvider,
+  DatabaseProviderDiagnostic,
+  DatabaseProviderLimits,
+  DbExecutor,
+  ExecuteResult,
+  ForeignKeyConstraint,
+  NotificationSubscription,
+  RowLockMode,
+  Row,
+  SqlDialect,
+  SqlParam,
+  TransactionCallback,
+} from "./Providers/types";
+
+// Schema and migrations
+export { SchemaDiffer, type SchemaDiff, type AdditiveSchemaOperation } from "./Schema/SchemaDiffer";
+export { Migrator, type MigrationResult } from "./Schema/Migrator";
+export {
+  MigrationRunner,
+  type Migration,
+  type MigrationContext,
+  type VersionedMigrationResult,
+} from "./Schema/MigrationRunner";
+export type {
+  IntrospectedColumn,
+  IntrospectedIndex,
+  IntrospectedSchema,
+  IntrospectedTable,
+  CanonicalDefault,
+  GenerationStrategy,
+  IntrospectedPrimaryKey,
+  IntrospectedForeignKey,
+  IntrospectedCheck,
+} from "./Schema/introspection";
+export type { SchemaDifferenceCode, SafeSchemaDescriptor, SchemaDifference, SchemaVerificationResult } from "./Schema/ExactSchemaVerifier";
+export { SchemaAdmissionError, SchemaMigrationRequiredError, SchemaVerificationError } from "./errors";
+export type { SchemaAdmissionErrorCode } from "./errors";
+export { compileCheck, renderCheck } from "./Schema/CheckExpression";
+export type { CheckAst, CheckExpression, CheckOperand, CheckField, CheckPredicate, CheckScalar } from "./Schema/CheckExpression";
+export { defineOrmOwnedStoreV1 } from "./Schema/OrmOwnedStore";
+export type { OrmCatalogScopeV1, OrmOwnedStoreDefinitionV1 } from "./Schema/OrmOwnedStore";
+
+// Errors
+export { isUnknownTransactionOutcome, TransactionOutcomeUnknownError } from "./Providers/transactionOutcome";
+export {
+  ConcurrentTransactionScopeError,
+  DbUpdateError,
+  EntityNotFoundError,
+  EntityNotMappedError,
+  ModelBuildError,
+  OrmError,
+  OrmValidationError,
+  UniqueViolationError,
+  PostCommitError,
+  isCommittedOutcome,
+  OrmTransactionScopeError,
+  OrmProviderIdentityMismatchError,
+  OrmDatabaseTimeError,
+  OrmTrackedMutationConflictError,
+  OrmUnsafeImmediateMutationError,
+  OrmUndeclaredConflictTargetError,
+  OrmOwnedStoreAdmissionError,
+} from "./errors";
+export type { OrmOwnedStoreAdmissionErrorCode } from "./errors";

package/library/orm/runtime.ts

@@ -0,0 +1,14 @@
+import type { OrmModel } from "./Metadata/OrmModel";
+import type { DatabaseProvider } from "./Providers/types";
+import type { ChangeTracker } from "./Tracking/ChangeTracker";
+
+/**
+ * Internal runtime that `DbContext` passes to `DbSet`. Kept in a separate
+ * module to break import cycles between the context, the set and the tracker.
+ */
+export interface DbContextRuntime {
+  readonly provider: DatabaseProvider;
+  readonly models: OrmModel;
+  readonly tracker: ChangeTracker;
+  readonly runImmediateOperation: <T>(operation: () => T | Promise<T>) => Promise<T>;
+}

package/library/redaction/index.ts

@@ -0,0 +1,166 @@
+const DEFAULT_REPLACEMENT = "***";
+const CIRCULAR = "[Circular]";
+
+const DEFAULT_SENSITIVE_FRAGMENTS = [
+  "password",
+  "passwd",
+  "passphrase",
+  "secret",
+  "token",
+  "apikey",
+  "authorization",
+  "cookie",
+  "privatekey",
+  "clientsecret",
+  "credential",
+  "sessionid",
+];
+
+const SECRET_TEXT_PATTERN =
+  /\b(password|passwd|passphrase|secret|token|api[-_]?key|cookie|set-cookie|private[-_]?key|client[-_]?secret)\b(\s*[:=]\s*)("[^"]*"|'[^']*'|[^,\s}]+)/gi;
+const BEARER_TEXT_PATTERN = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi;
+
+export interface SensitiveRedactionOptions {
+  readonly replacement?: string;
+  readonly sensitiveKeys?: readonly (string | RegExp)[];
+  readonly maxDepth?: number;
+}
+
+interface NormalizedRedactionOptions {
+  readonly replacement: string;
+  readonly sensitiveKeys: readonly (string | RegExp)[];
+  readonly maxDepth: number;
+}
+
+export function redactSensitive<T>(value: T, options: SensitiveRedactionOptions = {}): T {
+  return redactValue(value, undefined, normalizeOptions(options), new WeakSet<object>(), 0) as T;
+}
+
+export function redactSensitiveText(value: string, options: SensitiveRedactionOptions = {}): string {
+  return redactText(value, normalizeOptions(options).replacement);
+}
+
+export function redactTraceValues<T>(values: readonly T[], options: SensitiveRedactionOptions = {}): readonly T[] {
+  const replacement = normalizeOptions(options).replacement as T;
+  return values.map(() => replacement);
+}
+
+export function isSensitiveKey(key: string, options: SensitiveRedactionOptions = {}): boolean {
+  return keyIsSensitive(key, normalizeOptions(options));
+}
+
+function normalizeOptions(options: SensitiveRedactionOptions): NormalizedRedactionOptions {
+  return {
+    replacement: options.replacement ?? DEFAULT_REPLACEMENT,
+    sensitiveKeys: options.sensitiveKeys ?? [],
+    maxDepth: options.maxDepth ?? 8,
+  };
+}
+
+function redactValue(
+  value: unknown,
+  key: string | undefined,
+  options: NormalizedRedactionOptions,
+  seen: WeakSet<object>,
+  depth: number,
+): unknown {
+  if (key !== undefined && keyIsSensitive(key, options)) {
+    return options.replacement;
+  }
+  if (typeof value === "string") {
+    return redactText(value, options.replacement);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (depth >= options.maxDepth) {
+    return options.replacement;
+  }
+  if (seen.has(value)) {
+    return CIRCULAR;
+  }
+  seen.add(value);
+  if (value instanceof Error) {
+    return redactError(value, options, seen, depth);
+  }
+  if (isRedactedJsonObject(value)) {
+    return options.replacement;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item, undefined, options, seen, depth + 1));
+  }
+
+  const output: Record<string, unknown> = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    output[childKey] = redactValue(childValue, childKey, options, seen, depth + 1);
+  }
+  return output;
+}
+
+function redactError(
+  error: Error,
+  options: NormalizedRedactionOptions,
+  seen: WeakSet<object>,
+  depth: number,
+): Record<string, unknown> {
+  const output: Record<string, unknown> = {
+    name: error.name,
+    message: redactText(error.message, options.replacement),
+  };
+  if (error.stack !== undefined) {
+    output.stack = redactText(error.stack, options.replacement);
+  }
+  for (const [key, value] of Object.entries(error)) {
+    output[key] = redactValue(value, key, options, seen, depth + 1);
+  }
+  return output;
+}
+
+function isRedactedJsonObject(value: object): boolean {
+  const toJson = (value as { toJSON?: unknown }).toJSON;
+  if (typeof toJson !== "function") {
+    return false;
+  }
+  try {
+    return toJson.call(value) === DEFAULT_REPLACEMENT;
+  } catch {
+    return false;
+  }
+}
+
+function keyIsSensitive(key: string, options: NormalizedRedactionOptions): boolean {
+  const normalized = normalizeKey(key);
+  if (DEFAULT_SENSITIVE_FRAGMENTS.some((fragment) => normalized.includes(fragment))) {
+    return true;
+  }
+  for (const sensitiveKey of options.sensitiveKeys) {
+    if (typeof sensitiveKey === "string") {
+      const custom = normalizeKey(sensitiveKey);
+      if (custom.length > 0 && normalized.includes(custom)) {
+        return true;
+      }
+      continue;
+    }
+    sensitiveKey.lastIndex = 0;
+    if (sensitiveKey.test(key)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function normalizeKey(key: string): string {
+  return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function redactText(value: string, replacement: string): string {
+  return value
+    .replace(SECRET_TEXT_PATTERN, (_match, name: string, separator: string) => `${name}${separator}${replacement}`)
+    .replace(BEARER_TEXT_PATTERN, (_match, scheme: string) => `${scheme} ${replacement}`);
+}

package/library/ui/UiProfile.ts

@@ -0,0 +1,77 @@
+import type {
+  UiControllerClass,
+  UiCustomPagesProfileAuthoringOptions,
+  UiProfileAuthoringOptions,
+  UiRequestClass,
+  UiResponseReference,
+} from "./uiProfileAuthoring";
+import { defineUiProfileAuthoringMetadata } from "./uiProfileAuthoringMetadata";
+
+/**
+ * Stores process-local, reference-based UI authoring metadata on a profile
+ * class. No JSON normalization or controller/DTO name matching happens here.
+ */
+export function UiProfile<
+  Controller extends UiControllerClass = UiControllerClass,
+  Response extends UiResponseReference | undefined = undefined,
+  ListRequest extends UiRequestClass | undefined = undefined,
+  CreateRequest extends UiRequestClass | undefined = undefined,
+  EditRequest extends UiRequestClass | undefined = undefined,
+>(
+  profile:
+    | UiProfileAuthoringOptions<Controller, Response, ListRequest, CreateRequest, EditRequest>
+    | UiCustomPagesProfileAuthoringOptions,
+) {
+  return uiProfileDecorator(profile);
+}
+
+function uiProfileDecorator(profile: UiProfileAuthoringOptions<any, any, any, any, any> | UiCustomPagesProfileAuthoringOptions) {
+  return (value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
+    defineUiProfileAuthoringMetadata(value, context.metadata, profile as import("./uiProfileAuthoring").AnyUiProfileAuthoringOptions);
+  };
+}
+
+export {
+  uiOperation,
+  uiEndpoint,
+} from "./uiProfileAuthoring";
+export {
+  isUiProfileAuthoringClass,
+  uiProfileAuthoringMetadataOf,
+} from "./uiProfileAuthoringMetadata";
+export type {
+  AnyUiProfileAuthoringOptions,
+  UiActionIntentOverride,
+  UiActionPlacementOverride,
+  UiAuthoringClass,
+  UiControllerClass,
+  UiControllerMethod,
+  UiControllerMethodKey,
+  UiControllerMethodReference,
+  UiCustomPageAuthoring,
+  UiCustomPageBaseAuthoring,
+  UiCustomPagesProfileAuthoringOptions,
+  UiDashboardBlockAuthoring,
+  UiDashboardPageAuthoring,
+  UiDataFieldKey,
+  UiDeleteAuthoringOverride,
+  UiDocumentPageAuthoring,
+  UiEndpointAuthoringOptions,
+  UiEndpointReference,
+  UiFeaturePageAuthoring,
+  UiFieldSelection,
+  UiListFieldOverride,
+  UiFormFieldMap,
+  UiFormFieldOverride,
+  UiFormAuthoringOverride,
+  UiListAuthoringOverride,
+  UiProfileAuthoringOptions,
+  UiProfileNavigationOverride,
+  UiProfileOperations,
+  UiRequestClass,
+  UiResponseReference,
+  UiResponseValue,
+  UiSettingsPageAuthoring,
+  UiSortField,
+} from "./uiProfileAuthoring";
+export type { UiProfileAuthoringMetadata } from "./uiProfileAuthoringMetadata";

package/library/ui/compiled-v1.ts

@@ -0,0 +1,131 @@
+import type { UiDiagnosticV1 } from "./diagnostics-v1";
+import type {
+  UiActionIntentV1,
+  UiActionPlacementV1,
+  UiDetailProfileV1,
+  UiFormProfileV1,
+  UiFormsProfileV1,
+  UiListProfileV1,
+} from "./profile-v1";
+import type { UiJsonObject } from "./serialization";
+
+export const COMPILED_UI_SURFACE_V1_API_VERSION = "ui.bazis.dev/v1" as const;
+export const COMPILED_UI_SURFACE_V1_KIND = "CompiledUiSurface" as const;
+
+export interface CompiledUiSurfaceV1 {
+  readonly apiVersion: typeof COMPILED_UI_SURFACE_V1_API_VERSION;
+  readonly kind: typeof COMPILED_UI_SURFACE_V1_KIND;
+  readonly metadata: CompiledUiSurfaceMetadataV1;
+  readonly links: CompiledUiSurfaceLinksV1;
+  readonly spec: CompiledUiSurfaceSpecV1;
+  readonly diagnostics?: readonly UiDiagnosticV1[];
+}
+
+export interface CompiledUiSurfaceMetadataV1 {
+  readonly surface: string;
+  readonly revision: string;
+}
+
+export interface CompiledUiSurfaceLinksV1 {
+  readonly openapi: string;
+  readonly session?: string;
+}
+
+export interface CompiledUiSurfaceSpecV1 {
+  readonly navigation: readonly CompiledUiNavigationItemV1[];
+  readonly resources: readonly CompiledUiResourceV1[];
+  readonly customPages?: readonly CompiledUiCustomPageV1[];
+  readonly requiredRendererCapabilities: readonly string[];
+  readonly extensions?: UiJsonObject;
+}
+
+export interface CompiledUiNavigationItemV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly route: string;
+  readonly resource?: string;
+  readonly page?: string;
+  readonly group?: string;
+  readonly icon?: string;
+  readonly order?: number;
+}
+
+export interface CompiledUiCustomPageBaseV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly route: string;
+}
+
+export interface CompiledUiSettingsPageV1 extends CompiledUiCustomPageBaseV1 {
+  readonly kind: "settings";
+  readonly operations: {
+    readonly read: CompiledUiOperationRefV1;
+    readonly update?: CompiledUiOperationRefV1;
+  };
+  readonly form?: UiFormProfileV1;
+}
+
+export interface CompiledUiDocumentPageV1 extends CompiledUiCustomPageBaseV1 {
+  readonly kind: "document";
+  readonly operation: CompiledUiOperationRefV1;
+}
+
+export interface CompiledUiDashboardBlockV1 {
+  readonly id: string;
+  readonly kind: "metric" | "document";
+  readonly title: string;
+  readonly operation: CompiledUiOperationRefV1;
+}
+
+export interface CompiledUiDashboardPageV1 extends CompiledUiCustomPageBaseV1 {
+  readonly kind: "dashboard";
+  readonly blocks: readonly CompiledUiDashboardBlockV1[];
+}
+
+export interface CompiledUiFeaturePageV1 extends CompiledUiCustomPageBaseV1 {
+  readonly kind: "feature";
+  readonly renderer: string;
+}
+
+export type CompiledUiCustomPageV1 =
+  | CompiledUiSettingsPageV1
+  | CompiledUiDocumentPageV1
+  | CompiledUiDashboardPageV1
+  | CompiledUiFeaturePageV1;
+
+export interface CompiledUiOperationRefV1 {
+  readonly operationId: string;
+}
+
+export interface CompiledUiResourceOperationsV1 {
+  readonly list?: CompiledUiOperationRefV1;
+  readonly read?: CompiledUiOperationRefV1;
+  readonly create?: CompiledUiOperationRefV1;
+  readonly update?: CompiledUiOperationRefV1;
+  readonly delete?: CompiledUiOperationRefV1;
+}
+
+export interface CompiledUiResourceV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly singularTitle?: string;
+  readonly keyField?: string;
+  readonly route: string;
+  readonly operations: CompiledUiResourceOperationsV1;
+  readonly list?: UiListProfileV1;
+  readonly detail?: UiDetailProfileV1;
+  readonly forms?: UiFormsProfileV1;
+  readonly actions: readonly CompiledUiActionV1[];
+  readonly extensions?: UiJsonObject;
+}
+
+export interface CompiledUiActionV1 {
+  readonly id: string;
+  readonly title: string;
+  readonly operation: CompiledUiOperationRefV1;
+  readonly placements: readonly UiActionPlacementV1[];
+  readonly intent?: UiActionIntentV1;
+  readonly confirm?: string;
+  readonly refresh?: "none" | "resource" | "page" | "all";
+  readonly extensions?: UiJsonObject;
+}