@segmentstream-cloud/ontology 0.9.0 → 0.10.0

package/dist/analyze.js

@@ -1,5 +1,7 @@
 import { checkWarehouseSource } from "./warehouse-backed.js";
 import { Schema } from "effect";
+import { BLOB_UPLOAD_ANNOTATION } from "./blob.js";
+import { BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 import { isAction } from "./action.js";
 import { CONNECTION_KEY, isConnection } from "./connection.js";
 import { isEntity } from "./entity.js";
@@ -340,6 +342,19 @@ function resolveProperties(candidate, scope) {
     return properties;
 }
 function checkProperty(path, schema, definition, report) {
+    if (definition.type === "blob") {
+        if (definition.unique || "default" in definition) {
+            report("invalid-property", path, "Blob properties cannot be unique or have a default.");
+        }
+        if (!definition.accept?.length ||
+            definition.accept.some((type) => !BLOB_CONTENT_TYPES.includes(type)) ||
+            new Set(definition.accept).size !== definition.accept.length ||
+            !Number.isInteger(definition.maxBytes) ||
+            definition.maxBytes < 1 ||
+            definition.maxBytes > MAX_BLOB_BYTES) {
+            report("invalid-constraint", path, "Use supported content types and a limit from 1 byte to 25 MiB.");
+        }
+    }
     if (definition.type === "select") {
         checkSelectOptions(path, definition, report);
     }
@@ -563,7 +578,7 @@ function resolveInput(path, input, scope) {
     }
     try {
         const document = Schema.toJsonSchemaDocument(input, {
-            includeAnnotationKey: (key) => key === REFERENCE_ANNOTATION,
+            includeAnnotationKey: (key) => key === REFERENCE_ANNOTATION || key === BLOB_UPLOAD_ANNOTATION,
             onExcessProperty: "error",
         });
         const schema = document.schema;

package/dist/blob.d.ts

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+/** Metadata of an immutable file revision. Provider keys and grants never appear in records. */
+export declare const BlobValue: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly filename: Schema.String;
+    readonly contentType: Schema.String;
+    readonly size: Schema.Int;
+    readonly createdAt: Schema.String;
+}>;
+export type BlobValue = typeof BlobValue.Type;
+/** An opaque completed-upload ticket. Only the action runtime may resolve and consume it. */
+declare function uploadCodec(entity?: string, property?: string): Schema.decodeTo<Schema.Struct<{
+    readonly uploadId: Schema.String;
+}>, Schema.Struct<{
+    readonly upload_id: Schema.String;
+}>, never, never>;
+export declare const BlobUpload: Schema.Struct<{
+    readonly uploadId: Schema.String;
+}>;
+export type BlobUpload = typeof BlobUpload.Type;
+export declare const BLOB_UPLOAD_ANNOTATION = "x-ontology-upload";
+export declare const MAX_BLOB_BYTES: number;
+export declare const BLOB_CONTENT_TYPES: readonly ["application/pdf", "image/jpeg", "image/png", "text/plain"];
+type SchemaValue<S> = S extends {
+    readonly Type: infer T;
+} ? T : S extends Schema.optionalKey<infer Inner> ? Inner["Type"] : never;
+type BlobPropertyKey<P> = {
+    [K in keyof P]: NonNullable<SchemaValue<P[K]>> extends BlobValue ? K : never;
+}[keyof P] & string;
+/** Internal wire codec for session tickets and generated action inputs. */
+export declare function uploadInput(entity?: string, property?: string): ReturnType<typeof uploadCodec>;
+/** Declares which blob field an authored action's upload input may write. */
+export declare const uploads: {
+    for<const P extends Readonly<Record<string, unknown>>>(entity: {
+        readonly name: string;
+        readonly properties: P;
+    }, property: BlobPropertyKey<P>): typeof BlobUpload;
+};
+export {};

package/dist/blob.js

@@ -0,0 +1,49 @@
+import { Schema, SchemaTransformation } from "effect";
+import { nameToWire } from "./authoring-names.js";
+/** Metadata of an immutable file revision. Provider keys and grants never appear in records. */
+export const BlobValue = Schema.Struct({
+    id: Schema.String.check(Schema.isUUID()),
+    filename: Schema.String,
+    contentType: Schema.String,
+    size: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    createdAt: Schema.String,
+});
+/** An opaque completed-upload ticket. Only the action runtime may resolve and consume it. */
+function uploadCodec(entity, property) {
+    const id = Schema.String.check(Schema.isUUID());
+    return Schema.Struct({ upload_id: id })
+        .annotate({
+        ...(entity && property
+            ? {
+                description: `A completed upload for ${entity}.${property}.`,
+                "x-ontology-upload": { entity, property },
+            }
+            : {}),
+    })
+        .pipe(Schema.decodeTo(Schema.Struct({ uploadId: id }), SchemaTransformation.transform({
+        decode: (value) => ({ uploadId: value.upload_id }),
+        encode: (value) => ({ upload_id: value.uploadId }),
+    })));
+}
+export const BlobUpload = Schema.Struct({ uploadId: Schema.String.check(Schema.isUUID()) });
+export const BLOB_UPLOAD_ANNOTATION = "x-ontology-upload";
+export const MAX_BLOB_BYTES = 25 * 1024 * 1024;
+export const BLOB_CONTENT_TYPES = [
+    "application/pdf",
+    "image/jpeg",
+    "image/png",
+    "text/plain",
+];
+/** Internal wire codec for session tickets and generated action inputs. */
+export function uploadInput(entity, property) {
+    return uploadCodec(entity, property);
+}
+/** Declares which blob field an authored action's upload input may write. */
+export const uploads = {
+    for(entity, property) {
+        return BlobUpload.annotate({
+            description: `A completed upload for ${entity.name}.${property}.`,
+            "x-ontology-upload": { entity: nameToWire(entity.name), property: nameToWire(property) },
+        });
+    },
+};

package/dist/entity.d.ts

@@ -1,3 +1,4 @@
+import type { BlobUpload, BlobValue } from "./blob.js";
 import { Effect, type Schema } from "effect";
 import type { Measures } from "./measure.js";
 import type { WarehouseSource } from "./source.js";
@@ -39,6 +40,7 @@ type IsOptional<S> = S extends {
 type ValueOf<S> = S extends {
     readonly Type: infer T;
 } ? IsOptional<S> extends true ? T | null : T : never;
+type WriteValueOf<S> = NonNullable<ValueOf<S>> extends BlobValue ? BlobUpload | (null extends ValueOf<S> ? null : never) : ValueOf<S>;
 type RequiredOnCreate<S> = IsOptional<S> extends true ? false : S extends {
     readonly "~ontology.defaulted": true;
 } ? false : true;
@@ -68,9 +70,9 @@ export type EntityRecord<P, R> = Simplify<SystemFields & {
  * relationships take ids by relationship name (`{ lead: lead.id }`), `rel.many` a list of ids.
  */
 export type CreateValues<P, R> = Simplify<{
-    readonly [K in RequiredPropertyKeys<P>]: ValueOf<P[K]>;
+    readonly [K in RequiredPropertyKeys<P>]: WriteValueOf<P[K]>;
 } & {
-    readonly [K in Exclude<keyof P, RequiredPropertyKeys<P>>]?: ValueOf<P[K]>;
+    readonly [K in Exclude<keyof P, RequiredPropertyKeys<P>>]?: WriteValueOf<P[K]>;
 } & {
     readonly [K in RequiredOneKeys<R>]: string;
 } & {
@@ -80,7 +82,7 @@ export type CreateValues<P, R> = Simplify<{
 }>;
 /** Values for `update`. Handlers may write `managed` properties; the generated `update` may not. */
 export type UpdateValues<P, R> = Simplify<{
-    readonly [K in keyof P]?: ValueOf<P[K]>;
+    readonly [K in keyof P]?: WriteValueOf<P[K]>;
 } & {
     readonly [K in OneKeys<R>]?: R[K] extends OneRelationship<true> ? string | null : string;
 } & {

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export type { WarehouseSource } from "./source.js";
 export { m } from "./measure.js";
@@ -21,7 +22,7 @@ export type { Ontology } from "./ontology.js";
 export { DEFAULT_MEMBER_PERMISSIONS, generatedActionPermissions, grants, isAllowed, parsePermission, permissionsOf, READ_VERB, rolesGranting, WILDCARD, } from "./permissions.js";
 export type { ParsedPermission, PermissionHolder, RolePermissions } from "./permissions.js";
 export { p, PROPERTY_TYPES, propertyDefinition } from "./property.js";
-export type { AnyProperty, NumberOptions, Property, PropertyDefinition, PropertyOf, PropertyOptions, PropertyType, ReferenceOptions, SelectOption, SelectOptionInput, TextOptions, } from "./property.js";
+export type { AnyProperty, NumberOptions, Property, PropertyDefinition, PropertyOf, PropertyOptions, BlobOptions, PropertyType, ReferenceOptions, SelectOption, SelectOptionInput, TextOptions, } from "./property.js";
 export { ON_DELETE, rel } from "./relationship.js";
 export type { AnyRelationship, EntityTarget, LazyEntity, ManyOptions, ManyRelationship, OnDelete, OneOptions, OneRelationship, Phrase, } from "./relationship.js";
 export { renderCatalog } from "./render.js";
@@ -59,3 +60,5 @@ export { createOntologyService, ONTOLOGY_HASH_HEADER, REQUEST_ID_HEADER, } from
 export type { OntologyService } from "./service/service.js";
 export { applyMigration, CatalogInvalid, CatalogMismatch, isNoopMigration, migrate, MIGRATION_REFUSAL_CODES, MIGRATION_STEP_CLASSIFICATIONS, MIGRATION_STEP_KINDS, MigrationFailed, MigrationPlan, MigrationRefusal, MigrationRefused, MigrationStep, OntologyStorage, planMigration, readCatalog, } from "./migrate/index.js";
 export type { ApplyMigrationError, ApplyMigrationOptions, CatalogInput, MigrateInput, MigrationOptions, MigrationRefusalCode, MigrationResult, MigrationStepClassification, MigrationStepKind, PlanMigrationInput, } from "./migrate/index.js";
+export type { BlobStorageBinding } from "./storage/provider.js";
+export { runBlobStorageMaintenance } from "./storage/operator.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export { BlobValue, BlobUpload, uploads, BLOB_CONTENT_TYPES, MAX_BLOB_BYTES } from "./blob.js";
 export { warehouse, compatibleWarehouseColumn, warehouseColumnType, validateWarehouseSource, } from "./source.js";
 export { m } from "./measure.js";
 export { action, isAction } from "./action.js";
@@ -35,3 +36,4 @@ export { NotInvited, OntologyBackend } from "./service/runtime-contract.js";
 export { createOntologyService, ONTOLOGY_HASH_HEADER, REQUEST_ID_HEADER, } from "./service/service.js";
 // Migrations: the planner, the applier and the physical mapping they share with the runtime.
 export { applyMigration, CatalogInvalid, CatalogMismatch, isNoopMigration, migrate, MIGRATION_REFUSAL_CODES, MIGRATION_STEP_CLASSIFICATIONS, MIGRATION_STEP_KINDS, MigrationFailed, MigrationPlan, MigrationRefusal, MigrationRefused, MigrationStep, OntologyStorage, planMigration, readCatalog, } from "./migrate/index.js";
+export { runBlobStorageMaintenance } from "./storage/operator.js";

package/dist/manifest.d.ts

@@ -21,7 +21,7 @@ export declare const PropertyManifest: Schema.Struct<{
     readonly column: Schema.optionalKey<Schema.String>;
     readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
     readonly name: Schema.String;
-    readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+    readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
     readonly label: Schema.String;
     readonly description: Schema.optionalKey<Schema.String>;
     readonly optional: Schema.Boolean;
@@ -33,6 +33,8 @@ export declare const PropertyManifest: Schema.Struct<{
     readonly min: Schema.optionalKey<Schema.Number>;
     readonly max: Schema.optionalKey<Schema.Number>;
     readonly maxLength: Schema.optionalKey<Schema.Number>;
+    readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly maxBytes: Schema.optionalKey<Schema.Number>;
     readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
         readonly value: Schema.String;
         readonly label: Schema.String;
@@ -126,7 +128,7 @@ export declare const EntityManifest: Schema.Struct<{
         readonly column: Schema.optionalKey<Schema.String>;
         readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
         readonly name: Schema.String;
-        readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+        readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
         readonly label: Schema.String;
         readonly description: Schema.optionalKey<Schema.String>;
         readonly optional: Schema.Boolean;
@@ -138,6 +140,8 @@ export declare const EntityManifest: Schema.Struct<{
         readonly min: Schema.optionalKey<Schema.Number>;
         readonly max: Schema.optionalKey<Schema.Number>;
         readonly maxLength: Schema.optionalKey<Schema.Number>;
+        readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly maxBytes: Schema.optionalKey<Schema.Number>;
         readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
             readonly value: Schema.String;
             readonly label: Schema.String;
@@ -227,7 +231,7 @@ export declare const OntologyManifestWire: Schema.encodeKeys<Schema.Struct<{
             readonly column: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
             readonly name: Schema.String;
-            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
             readonly label: Schema.String;
             readonly description: Schema.optionalKey<Schema.String>;
             readonly optional: Schema.Boolean;
@@ -239,6 +243,8 @@ export declare const OntologyManifestWire: Schema.encodeKeys<Schema.Struct<{
             readonly min: Schema.optionalKey<Schema.Number>;
             readonly max: Schema.optionalKey<Schema.Number>;
             readonly maxLength: Schema.optionalKey<Schema.Number>;
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly maxBytes: Schema.optionalKey<Schema.Number>;
             readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                 readonly value: Schema.String;
                 readonly label: Schema.String;
@@ -247,6 +253,7 @@ export declare const OntologyManifestWire: Schema.encodeKeys<Schema.Struct<{
         }>, {
             readonly renamedFrom: "renamed_from";
             readonly maxLength: "max_length";
+            readonly maxBytes: "max_bytes";
         }>>;
         readonly relationships: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
             readonly on: Schema.optionalKey<Schema.encodeKeys<Schema.Struct<{
@@ -359,7 +366,7 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
             readonly column: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
             readonly name: Schema.String;
-            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
             readonly label: Schema.String;
             readonly description: Schema.optionalKey<Schema.String>;
             readonly optional: Schema.Boolean;
@@ -371,6 +378,8 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
             readonly min: Schema.optionalKey<Schema.Number>;
             readonly max: Schema.optionalKey<Schema.Number>;
             readonly maxLength: Schema.optionalKey<Schema.Number>;
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly maxBytes: Schema.optionalKey<Schema.Number>;
             readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                 readonly value: Schema.String;
                 readonly label: Schema.String;
@@ -379,6 +388,7 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
         }>, {
             readonly renamedFrom: "renamed_from";
             readonly maxLength: "max_length";
+            readonly maxBytes: "max_bytes";
         }>>;
         readonly relationships: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
             readonly on: Schema.optionalKey<Schema.encodeKeys<Schema.Struct<{
@@ -514,7 +524,7 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
             readonly column: Schema.optionalKey<Schema.String>;
             readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
             readonly name: Schema.String;
-            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+            readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
             readonly label: Schema.String;
             readonly description: Schema.optionalKey<Schema.String>;
             readonly optional: Schema.Boolean;
@@ -526,6 +536,8 @@ export declare const OntologyManifest: Schema.Union<readonly [Schema.encodeKeys<
             readonly min: Schema.optionalKey<Schema.Number>;
             readonly max: Schema.optionalKey<Schema.Number>;
             readonly maxLength: Schema.optionalKey<Schema.Number>;
+            readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly maxBytes: Schema.optionalKey<Schema.Number>;
             readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                 readonly value: Schema.String;
                 readonly label: Schema.String;
@@ -623,7 +635,7 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
             readonly optional: boolean;
             readonly name: string;
             readonly label: string;
-            readonly type: "number" | "boolean" | "text" | "integer" | "date" | "timestamp" | "select" | "email" | "url" | "json";
+            readonly type: "number" | "boolean" | "text" | "integer" | "date" | "timestamp" | "select" | "email" | "url" | "json" | "blob";
             readonly unique: boolean;
             readonly managed: boolean;
             readonly column?: string | undefined;
@@ -640,6 +652,8 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
             }[] | undefined;
             readonly renamedFrom?: string | undefined;
             readonly display?: string | undefined;
+            readonly accept?: readonly string[] | undefined;
+            readonly maxBytes?: number | undefined;
         }[];
         readonly relationships: readonly {
             readonly name: string;
@@ -721,7 +735,7 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
             readonly optional: boolean;
             readonly name: string;
             readonly label: string;
-            readonly type: "number" | "boolean" | "text" | "integer" | "date" | "timestamp" | "select" | "email" | "url" | "json";
+            readonly type: "number" | "boolean" | "text" | "integer" | "date" | "timestamp" | "select" | "email" | "url" | "json" | "blob";
             readonly unique: boolean;
             readonly managed: boolean;
             readonly column?: string | undefined;
@@ -738,6 +752,8 @@ export declare const decodeManifestDocument: (value: unknown) => Effect.Effect<{
             }[] | undefined;
             readonly renamedFrom?: string | undefined;
             readonly display?: string | undefined;
+            readonly accept?: readonly string[] | undefined;
+            readonly maxBytes?: number | undefined;
         }[];
         readonly relationships: readonly {
             readonly name: string;

package/dist/manifest.js

@@ -36,6 +36,8 @@ export const PropertyManifest = Schema.Struct({
     min: Schema.optionalKey(Schema.Number),
     max: Schema.optionalKey(Schema.Number),
     maxLength: Schema.optionalKey(Schema.Number),
+    accept: Schema.optionalKey(Schema.Array(Schema.String)),
+    maxBytes: Schema.optionalKey(Schema.Number),
     options: Schema.optionalKey(Schema.Array(SelectOptionManifest)),
 });
 /**
@@ -160,7 +162,11 @@ const OntologyManifestModel = Schema.Struct({
     /** The connections the actions call. Written only when there are some; absent reads as none. */
     connections: Schema.optionalKey(Schema.Array(ConnectionManifest)),
 });
-const PropertyManifestWire = PropertyManifest.pipe(Schema.encodeKeys({ renamedFrom: "renamed_from", maxLength: "max_length" }));
+const PropertyManifestWire = PropertyManifest.pipe(Schema.encodeKeys({
+    renamedFrom: "renamed_from",
+    maxLength: "max_length",
+    maxBytes: "max_bytes",
+}));
 const OnDeleteWire = Schema.Literals(["set_null", "cascade", "restrict"]).pipe(Schema.decodeTo(Schema.Literals(ON_DELETE), SchemaTransformation.transform({
     decode: (value) => (value === "set_null" ? "setNull" : value),
     encode: (value) => (value === "setNull" ? "set_null" : value),
@@ -265,6 +271,8 @@ function propertyManifest({ name, definition }) {
         ...(definition.min !== undefined ? { min: definition.min } : {}),
         ...(definition.max !== undefined ? { max: definition.max } : {}),
         ...(definition.maxLength !== undefined ? { maxLength: definition.maxLength } : {}),
+        ...(definition.accept !== undefined ? { accept: definition.accept } : {}),
+        ...(definition.maxBytes !== undefined ? { maxBytes: definition.maxBytes } : {}),
         ...(definition.options !== undefined
             ? {
                 options: definition.options.map((option) => ({

package/dist/migrate/model.d.ts

@@ -48,7 +48,7 @@ export declare const MigrationPlan: Schema.Struct<{
                 readonly column: Schema.optionalKey<Schema.String>;
                 readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
                 readonly name: Schema.String;
-                readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+                readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
                 readonly label: Schema.String;
                 readonly description: Schema.optionalKey<Schema.String>;
                 readonly optional: Schema.Boolean;
@@ -60,6 +60,8 @@ export declare const MigrationPlan: Schema.Struct<{
                 readonly min: Schema.optionalKey<Schema.Number>;
                 readonly max: Schema.optionalKey<Schema.Number>;
                 readonly maxLength: Schema.optionalKey<Schema.Number>;
+                readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly maxBytes: Schema.optionalKey<Schema.Number>;
                 readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                     readonly value: Schema.String;
                     readonly label: Schema.String;
@@ -68,6 +70,7 @@ export declare const MigrationPlan: Schema.Struct<{
             }>, {
                 readonly renamedFrom: "renamed_from";
                 readonly maxLength: "max_length";
+                readonly maxBytes: "max_bytes";
             }>>;
             readonly relationships: Schema.$Array<Schema.encodeKeys<Schema.Struct<{
                 readonly on: Schema.optionalKey<Schema.encodeKeys<Schema.Struct<{
@@ -182,7 +185,7 @@ export declare const MigrationPlan: Schema.Struct<{
                 readonly column: Schema.optionalKey<Schema.String>;
                 readonly scope: Schema.optionalKey<Schema.$Array<Schema.String>>;
                 readonly name: Schema.String;
-                readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"]>;
+                readonly type: Schema.Literals<readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"]>;
                 readonly label: Schema.String;
                 readonly description: Schema.optionalKey<Schema.String>;
                 readonly optional: Schema.Boolean;
@@ -194,6 +197,8 @@ export declare const MigrationPlan: Schema.Struct<{
                 readonly min: Schema.optionalKey<Schema.Number>;
                 readonly max: Schema.optionalKey<Schema.Number>;
                 readonly maxLength: Schema.optionalKey<Schema.Number>;
+                readonly accept: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly maxBytes: Schema.optionalKey<Schema.Number>;
                 readonly options: Schema.optionalKey<Schema.$Array<Schema.Struct<{
                     readonly value: Schema.String;
                     readonly label: Schema.String;

package/dist/migrate/plan.js

@@ -1,5 +1,6 @@
+import { BLOB_TABLES_DDL } from "../storage/tables.js";
 import { SNAKE_CASE_NAME, isSystemProperty, toSnakeCase } from "../names.js";
-import { CATALOG_TABLE_DDL, MAX_IDENTIFIER_LENGTH, USER_TABLE, addConstraintStatement, columnDefinition, constraintDefinition, createEnumStatement, createIndexStatement, createTableStatement, defaultExpression, entityStorage, enumTypeName, fieldColumnName, joinTable, propertyCheck, propertyColumn, propertyEnum, quoteIdentifier, quoteLiteral, relationshipColumn, RUNTIME_TABLES_DDL, relationshipForeignKey, SYSTEM_COLUMNS, tableName, } from "./storage.js";
+import { CATALOG_TABLE_DDL, MAX_IDENTIFIER_LENGTH, USER_TABLE, addConstraintStatement, columnDefinition, constraintDefinition, createEnumStatement, createIndexStatement, createTableStatement, defaultExpression, entityStorage, enumTypeName, fieldColumnName, joinTable, propertyCheck, blobForeignKey, propertyColumn, propertyEnum, quoteIdentifier, quoteLiteral, relationshipColumn, RUNTIME_TABLES_DDL, relationshipForeignKey, SYSTEM_COLUMNS, tableName, } from "./storage.js";
 const GLOBAL_KINDS = new Set(["table", "type", "index"]);
 function step(input) {
     return {
@@ -72,6 +73,15 @@ export function planMigration(input) {
             sql: RUNTIME_TABLES_DDL,
         }));
     }
+    if (storedTargets.some((entity) => entity.properties.some((property) => property.type === "blob")) &&
+        !current?.entities.some((entity) => entity.properties.some((property) => property.type === "blob"))) {
+        draft.runtimeTables.push(step({
+            kind: "createCatalog",
+            classification: "additive",
+            description: "Create the ontology's file revision and upload tables.",
+            sql: BLOB_TABLES_DDL,
+        }));
+    }
     planDrops({ pairs, removedEntities, addedEntities, allowDrops, draft });
     const renamed = planRenames({ pairs, draft });
     const appliedNames = new Set(storageObjects(currentEntities)
@@ -573,6 +583,12 @@ function logicalRenames(pairs, refusals) {
                 path: `${pair.target.name}.properties.${to}`,
                 description: `Rename property ${pair.target.name}.${from} to ${to}.`,
                 apply: (model) => renameProperty(model, pair.target.id, from, to),
+                ...(pair.current.properties.some((property) => property.name === from && property.type === "blob")
+                    ? {
+                        metadataSql: ["_blobs", "_blob_uploads", "_blob_references"].map((table) => `UPDATE ${quoteIdentifier(table)} SET property_id = ${quoteLiteral(to)} ` +
+                            `WHERE entity_id = ${quoteLiteral(pair.target.id)} AND property_id = ${quoteLiteral(from)}`),
+                    }
+                    : {}),
             });
         }
     }
@@ -595,7 +611,7 @@ function planRenames(input) {
             kind: rename.kind,
             classification: "rename",
             description: rename.description,
-            sql: statements,
+            sql: [...statements, ...(rename.metadataSql ?? [])],
         }));
         model = next;
     }
@@ -893,6 +909,14 @@ function planEntityChanges(input) {
         }
     }
     for (const property of pair.addedProperties) {
+        if (property.type === "blob") {
+            draft.foreignKeys.push(step({
+                kind: "addProperty",
+                classification: "additive",
+                description: `Reference the file revision for ${entity}.${property.name}.`,
+                sql: [addConstraintStatement(table, blobForeignKey(entity, property))],
+            }));
+        }
         const enumStorage = propertyEnum(entity, property);
         const check = propertyCheck(entity, property);
         const column = propertyColumn(entity, property);

package/dist/migrate/storage.d.ts

@@ -30,6 +30,7 @@ export declare const COLUMN_TYPES: {
     readonly date: "date";
     readonly timestamp: "timestamptz";
     readonly json: "jsonb";
+    readonly blob: "uuid";
 };
 export interface ColumnStorage {
     readonly name: string;
@@ -130,6 +131,7 @@ export declare function checkExpression(property: PropertyManifest): string | un
 export declare function propertyColumn(entity: string, property: PropertyManifest): ColumnStorage;
 export declare function propertyCheck(entity: string, property: PropertyManifest): ConstraintStorage | undefined;
 export declare function propertyEnum(entity: string, property: PropertyManifest): EnumStorage | undefined;
+export declare function blobForeignKey(entity: string, property: PropertyManifest): ConstraintStorage;
 /** The key column of a `rel.one`. */
 export declare function relationshipColumn(relationship: RelationshipManifest): ColumnStorage;
 /** The foreign key of a `rel.one`, with its `onDelete` action. */

package/dist/migrate/storage.js

@@ -29,6 +29,7 @@ export const COLUMN_TYPES = {
     date: "date",
     timestamp: "timestamptz",
     json: "jsonb",
+    blob: "uuid",
 };
 const ON_DELETE_ACTIONS = {
     setNull: "SET NULL",
@@ -198,6 +199,15 @@ function foreignKeyDefinition(input) {
         `REFERENCES ${quoteIdentifier(input.references)} (${quoteIdentifier(SYSTEM_COLUMNS.id)})`;
     return input.onDelete === undefined ? reference : `${reference} ON DELETE ${input.onDelete}`;
 }
+export function blobForeignKey(entity, property) {
+    const column = columnName(property.name);
+    return {
+        name: foreignKeyName(entity, column),
+        kind: "foreignKey",
+        definition: foreignKeyDefinition({ column, references: "_blobs" }),
+        references: "_blobs",
+    };
+}
 function userReference(table, column) {
     return {
         name: foreignKeyName(table, column),
@@ -389,6 +399,9 @@ export function entityStorage(entity) {
                 userReference(table, SYSTEM_COLUMNS.created_by),
                 userReference(table, SYSTEM_COLUMNS.updated_by),
                 ...checks,
+                ...entity.properties
+                    .filter((property) => property.type === "blob")
+                    .map((property) => blobForeignKey(entity.name, property)),
                 ...ones.map((relationship) => relationshipForeignKey(entity.name, relationship)),
             ],
             indexes: entityIndexes(entity),

package/dist/property.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect";
+import { BlobValue, type BLOB_CONTENT_TYPES } from "./blob.js";
 /** The closed set of storage types. Each has a known column, JSON Schema, filters and rendering. */
-export declare const PROPERTY_TYPES: readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json"];
+export declare const PROPERTY_TYPES: readonly ["text", "email", "url", "integer", "number", "boolean", "date", "timestamp", "select", "json", "blob"];
 export type PropertyType = (typeof PROPERTY_TYPES)[number];
 /** Schema annotation that carries a property's storage metadata. */
 export declare const PROPERTY_ANNOTATION = "segmentstream/ontology/property";
@@ -40,6 +41,8 @@ export interface PropertyDefinition {
     readonly max?: number;
     readonly maxLength?: number;
     readonly options?: ReadonlyArray<SelectOption>;
+    readonly accept?: ReadonlyArray<string>;
+    readonly maxBytes?: number;
 }
 /**
  * A property: an Effect Schema of its value, usable in action inputs, with its storage metadata in
@@ -127,6 +130,11 @@ declare function ref<const O extends ReferenceOptions>(target: string | {
     readonly name: string;
 }, options?: O): ReferenceOf<O>;
 /** Property constructors. */
+export interface BlobOptions extends Omit<PropertyOptions<BlobValue>, "default" | "unique"> {
+    readonly accept: ReadonlyArray<(typeof BLOB_CONTENT_TYPES)[number]>;
+    readonly maxBytes?: number;
+}
+declare function blob<const O extends BlobOptions>(options: O): PropertyOf<BlobValue, O>;
 export declare const p: {
     readonly text: typeof text;
     readonly email: typeof email;
@@ -138,6 +146,7 @@ export declare const p: {
     readonly timestamp: typeof timestamp;
     readonly select: typeof select;
     readonly json: typeof json;
+    readonly blob: typeof blob;
     readonly ref: typeof ref;
 };
 /** The storage metadata of a schema built with a `p.*` constructor, or `undefined` for any other value. */

package/dist/property.js

@@ -1,5 +1,6 @@
 import { Schema } from "effect";
 import { humanize } from "./names.js";
+import { BlobValue, MAX_BLOB_BYTES } from "./blob.js";
 import { nameToWire } from "./authoring-names.js";
 /** The closed set of storage types. Each has a known column, JSON Schema, filters and rendering. */
 export const PROPERTY_TYPES = [
@@ -13,6 +14,7 @@ export const PROPERTY_TYPES = [
     "timestamp",
     "select",
     "json",
+    "blob",
 ];
 /** Schema annotation that carries a property's storage metadata. */
 export const PROPERTY_ANNOTATION = "segmentstream/ontology/property";
@@ -47,6 +49,8 @@ function construct({ type, base, options, checks = [], format, selectOptions, })
         ...(options.min !== undefined ? { min: options.min } : {}),
         ...(options.max !== undefined ? { max: options.max } : {}),
         ...(options.maxLength !== undefined ? { maxLength: options.maxLength } : {}),
+        ...(options.accept !== undefined ? { accept: options.accept } : {}),
+        ...(options.maxBytes !== undefined ? { maxBytes: options.maxBytes } : {}),
         ...(selectOptions !== undefined ? { options: selectOptions } : {}),
     };
     // Annotations go on the base node, before the checks, so that the JSON Schema keeps them at the top
@@ -176,7 +180,13 @@ function ref(target, options) {
     }).check(Schema.isPattern(UUID));
     return (settings.optional === true ? Schema.optionalKey(schema) : schema);
 }
-/** Property constructors. */
+function blob(options) {
+    return construct({
+        type: "blob",
+        base: BlobValue,
+        options: { ...options, maxBytes: options.maxBytes ?? MAX_BLOB_BYTES },
+    });
+}
 export const p = {
     text,
     email,
@@ -188,6 +198,7 @@ export const p = {
     timestamp,
     select,
     json,
+    blob,
     ref,
 };
 function findAnnotation(ast, key) {

package/dist/query.js

@@ -1,5 +1,6 @@
 import { Schema } from "effect";
 import { wireStruct } from "./wire.js";
+import { BlobValue } from "./blob.js";
 /**
  * The query language of `find` and of the HTTP API's list and query endpoints.
  *
@@ -194,12 +195,13 @@ export function fieldValueSchema(field) {
         case "json":
             return JsonValue;
         case "uuid":
+        case "blob":
             return UuidValue;
     }
 }
 /** Fields a query can sort on: every field but `json` properties. */
 export function isOrderable(field) {
-    return field.storage !== "json";
+    return field.storage !== "json" && field.storage !== "blob";
 }
 const FILTER_IDENTIFIERS = {
     text: "TextFilter",
@@ -212,6 +214,7 @@ const FILTER_IDENTIFIERS = {
     timestamp: "TimestampFilter",
     json: "JsonFilter",
     uuid: "IdFilter",
+    blob: "IdFilter",
 };
 const FILTER_DESCRIPTIONS = {
     TextFilter: "contains and startsWith ignore case.",
@@ -413,6 +416,8 @@ function recordValueSchema(field) {
                 return Schema.Literals(field.options ?? []);
             case "json":
                 return Schema.Json;
+            case "blob":
+                return BlobValue;
             default:
                 return Schema.String;
         }