@contractspec/lib.files 1.56.1 → 1.58.0

package/dist/node/entities/index.js

@@ -0,0 +1,235 @@
+// src/entities/index.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var StorageProviderEnum = defineEntityEnum({
+  name: "StorageProvider",
+  values: ["LOCAL", "S3", "GCS", "AZURE", "CLOUDFLARE"],
+  schema: "lssm_files",
+  description: "Storage backend provider."
+});
+var FileStatusEnum = defineEntityEnum({
+  name: "FileStatus",
+  values: [
+    "PENDING",
+    "UPLOADED",
+    "PROCESSING",
+    "READY",
+    "ERROR",
+    "DELETED"
+  ],
+  schema: "lssm_files",
+  description: "File processing status."
+});
+var FileEntity = defineEntity({
+  name: "File",
+  description: "An uploaded file.",
+  schema: "lssm_files",
+  map: "file",
+  fields: {
+    id: field.id({ description: "Unique file identifier" }),
+    name: field.string({ description: "Original file name" }),
+    mimeType: field.string({ description: "MIME type" }),
+    size: field.int({ description: "File size in bytes" }),
+    storageProvider: field.enum("StorageProvider", {
+      default: "LOCAL",
+      description: "Storage backend"
+    }),
+    storagePath: field.string({ description: "Path in storage backend" }),
+    storageKey: field.string({
+      isOptional: true,
+      description: "Storage key/bucket"
+    }),
+    checksum: field.string({
+      isOptional: true,
+      description: "SHA-256 checksum"
+    }),
+    etag: field.string({ isOptional: true, description: "Storage ETag" }),
+    status: field.enum("FileStatus", {
+      default: "PENDING",
+      description: "File status"
+    }),
+    isPublic: field.boolean({
+      default: false,
+      description: "Whether file is publicly accessible"
+    }),
+    expiresAt: field.dateTime({
+      isOptional: true,
+      description: "Auto-delete timestamp"
+    }),
+    ownerId: field.string({ description: "User who uploaded" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    tags: field.json({
+      isOptional: true,
+      description: "Tags for categorization"
+    }),
+    width: field.int({
+      isOptional: true,
+      description: "Image width in pixels"
+    }),
+    height: field.int({
+      isOptional: true,
+      description: "Image height in pixels"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    versions: field.hasMany("FileVersion"),
+    attachments: field.hasMany("Attachment")
+  },
+  indexes: [
+    index.on(["ownerId"]),
+    index.on(["orgId"]),
+    index.on(["status"]),
+    index.on(["mimeType"]),
+    index.on(["storageProvider", "storagePath"])
+  ],
+  enums: [StorageProviderEnum, FileStatusEnum]
+});
+var FileVersionEntity = defineEntity({
+  name: "FileVersion",
+  description: "A version of a file.",
+  schema: "lssm_files",
+  map: "file_version",
+  fields: {
+    id: field.id({ description: "Unique version identifier" }),
+    fileId: field.foreignKey({ description: "Parent file" }),
+    version: field.int({ description: "Version number" }),
+    size: field.int({ description: "Version size in bytes" }),
+    storagePath: field.string({ description: "Path in storage backend" }),
+    checksum: field.string({
+      isOptional: true,
+      description: "SHA-256 checksum"
+    }),
+    comment: field.string({ isOptional: true, description: "Version comment" }),
+    changes: field.json({
+      isOptional: true,
+      description: "Change description"
+    }),
+    createdBy: field.string({ description: "User who created version" }),
+    createdAt: field.createdAt(),
+    file: field.belongsTo("File", ["fileId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.on(["fileId", "version"]),
+    index.unique(["fileId", "version"], { name: "file_version_unique" })
+  ]
+});
+var AttachmentEntity = defineEntity({
+  name: "Attachment",
+  description: "Links a file to an entity.",
+  schema: "lssm_files",
+  map: "attachment",
+  fields: {
+    id: field.id({ description: "Unique attachment identifier" }),
+    fileId: field.foreignKey({ description: "Attached file" }),
+    entityType: field.string({
+      description: "Target entity type (deal, listing, etc.)"
+    }),
+    entityId: field.string({ description: "Target entity ID" }),
+    attachmentType: field.string({
+      isOptional: true,
+      description: "Type of attachment (document, image, avatar, etc.)"
+    }),
+    name: field.string({
+      isOptional: true,
+      description: "Display name (overrides file name)"
+    }),
+    description: field.string({
+      isOptional: true,
+      description: "Attachment description"
+    }),
+    order: field.int({ default: 0, description: "Display order" }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Attachment-specific metadata"
+    }),
+    createdBy: field.string({ description: "User who created attachment" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    file: field.belongsTo("File", ["fileId"], ["id"], { onDelete: "Cascade" })
+  },
+  indexes: [
+    index.on(["entityType", "entityId"]),
+    index.on(["fileId"]),
+    index.on(["entityType", "entityId", "attachmentType"]),
+    index.unique(["fileId", "entityType", "entityId"], {
+      name: "attachment_unique"
+    })
+  ]
+});
+var UploadSessionEntity = defineEntity({
+  name: "UploadSession",
+  description: "Tracks a multipart upload session.",
+  schema: "lssm_files",
+  map: "upload_session",
+  fields: {
+    id: field.id({ description: "Unique session identifier" }),
+    fileName: field.string({ description: "Target file name" }),
+    mimeType: field.string({ description: "Expected MIME type" }),
+    totalSize: field.int({ description: "Total file size" }),
+    uploadId: field.string({
+      isOptional: true,
+      description: "Storage upload ID"
+    }),
+    uploadedBytes: field.int({
+      default: 0,
+      description: "Bytes uploaded so far"
+    }),
+    uploadedParts: field.json({
+      isOptional: true,
+      description: "Completed part info"
+    }),
+    status: field.string({
+      default: '"pending"',
+      description: "Session status"
+    }),
+    error: field.string({
+      isOptional: true,
+      description: "Error message if failed"
+    }),
+    fileId: field.string({
+      isOptional: true,
+      description: "Resulting file ID"
+    }),
+    ownerId: field.string({ description: "User who initiated upload" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization scope"
+    }),
+    expiresAt: field.dateTime({ description: "Session expiry time" }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt()
+  },
+  indexes: [index.on(["status", "expiresAt"]), index.on(["ownerId"])]
+});
+var fileEntities = [
+  FileEntity,
+  FileVersionEntity,
+  AttachmentEntity,
+  UploadSessionEntity
+];
+var filesSchemaContribution = {
+  moduleId: "@contractspec/lib.files",
+  entities: fileEntities,
+  enums: [StorageProviderEnum, FileStatusEnum]
+};
+export {
+  filesSchemaContribution,
+  fileEntities,
+  UploadSessionEntity,
+  StorageProviderEnum,
+  FileVersionEntity,
+  FileStatusEnum,
+  FileEntity,
+  AttachmentEntity
+};

package/dist/node/events.js

@@ -0,0 +1,219 @@
+// src/events.ts
+import { ScalarTypeEnum, defineSchemaModel } from "@contractspec/lib.schema";
+import { defineEvent } from "@contractspec/lib.contracts";
+var FileUploadedPayload = defineSchemaModel({
+  name: "FileUploadedEventPayload",
+  description: "Payload when a file is uploaded",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    storageProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orgId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    uploadedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var FileUpdatedPayload = defineSchemaModel({
+  name: "FileUpdatedEventPayload",
+  description: "Payload when a file is updated",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    changes: { type: ScalarTypeEnum.JSON(), isOptional: false },
+    updatedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    updatedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var FileDeletedPayload = defineSchemaModel({
+  name: "FileDeletedEventPayload",
+  description: "Payload when a file is deleted",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    storageProvider: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    storagePath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    deletedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    deletedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var FileVersionCreatedPayload = defineSchemaModel({
+  name: "FileVersionCreatedEventPayload",
+  description: "Payload when a file version is created",
+  fields: {
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    versionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    version: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    createdBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    comment: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AttachmentAttachedPayload = defineSchemaModel({
+  name: "AttachmentAttachedEventPayload",
+  description: "Payload when a file is attached to an entity",
+  fields: {
+    attachmentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    attachmentType: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    attachedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    attachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var AttachmentDetachedPayload = defineSchemaModel({
+  name: "AttachmentDetachedEventPayload",
+  description: "Payload when a file is detached from an entity",
+  fields: {
+    attachmentId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    entityId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    detachedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    detachedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var UploadSessionStartedPayload = defineSchemaModel({
+  name: "UploadSessionStartedEventPayload",
+  description: "Payload when an upload session starts",
+  fields: {
+    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    mimeType: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    totalSize: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    startedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var UploadSessionCompletedPayload = defineSchemaModel({
+  name: "UploadSessionCompletedEventPayload",
+  description: "Payload when an upload session completes",
+  fields: {
+    sessionId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    fileName: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    size: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    completedAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var FileUploadedEvent = defineEvent({
+  meta: {
+    key: "file.uploaded",
+    version: "1.0.0",
+    description: "A file has been uploaded.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "upload"]
+  },
+  payload: FileUploadedPayload
+});
+var FileUpdatedEvent = defineEvent({
+  meta: {
+    key: "file.updated",
+    version: "1.0.0",
+    description: "A file has been updated.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "update"]
+  },
+  payload: FileUpdatedPayload
+});
+var FileDeletedEvent = defineEvent({
+  meta: {
+    key: "file.deleted",
+    version: "1.0.0",
+    description: "A file has been deleted.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "delete"]
+  },
+  payload: FileDeletedPayload
+});
+var FileVersionCreatedEvent = defineEvent({
+  meta: {
+    key: "file.version_created",
+    version: "1.0.0",
+    description: "A new file version has been created.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "version", "create"]
+  },
+  payload: FileVersionCreatedPayload
+});
+var AttachmentAttachedEvent = defineEvent({
+  meta: {
+    key: "attachment.attached",
+    version: "1.0.0",
+    description: "A file has been attached to an entity.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "attachment", "attach"]
+  },
+  payload: AttachmentAttachedPayload
+});
+var AttachmentDetachedEvent = defineEvent({
+  meta: {
+    key: "attachment.detached",
+    version: "1.0.0",
+    description: "A file has been detached from an entity.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "attachment", "detach"]
+  },
+  payload: AttachmentDetachedPayload
+});
+var UploadSessionStartedEvent = defineEvent({
+  meta: {
+    key: "upload.session_started",
+    version: "1.0.0",
+    description: "An upload session has started.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "upload", "session", "start"]
+  },
+  payload: UploadSessionStartedPayload
+});
+var UploadSessionCompletedEvent = defineEvent({
+  meta: {
+    key: "upload.session_completed",
+    version: "1.0.0",
+    description: "An upload session has completed.",
+    stability: "stable",
+    owners: ["@platform.files"],
+    tags: ["files", "upload", "session", "complete"]
+  },
+  payload: UploadSessionCompletedPayload
+});
+var FileEvents = {
+  FileUploadedEvent,
+  FileUpdatedEvent,
+  FileDeletedEvent,
+  FileVersionCreatedEvent,
+  AttachmentAttachedEvent,
+  AttachmentDetachedEvent,
+  UploadSessionStartedEvent,
+  UploadSessionCompletedEvent
+};
+export {
+  UploadSessionStartedEvent,
+  UploadSessionCompletedEvent,
+  FileVersionCreatedEvent,
+  FileUploadedEvent,
+  FileUpdatedEvent,
+  FileEvents,
+  FileDeletedEvent,
+  AttachmentDetachedEvent,
+  AttachmentAttachedEvent
+};

package/dist/node/files.capability.js

@@ -0,0 +1,28 @@
+// src/files.capability.ts
+import { defineCapability, StabilityEnum } from "@contractspec/lib.contracts";
+var FilesCapability = defineCapability({
+  meta: {
+    key: "files",
+    version: "1.0.0",
+    kind: "data",
+    stability: StabilityEnum.Experimental,
+    description: "File storage and management",
+    owners: ["@platform.core"],
+    tags: ["files", "storage"]
+  }
+});
+var AttachmentsCapability = defineCapability({
+  meta: {
+    key: "attachments",
+    version: "1.0.0",
+    kind: "data",
+    stability: StabilityEnum.Experimental,
+    description: "File attachments for entities",
+    owners: ["@platform.core"],
+    tags: ["attachments", "files"]
+  }
+});
+export {
+  FilesCapability,
+  AttachmentsCapability
+};

package/dist/node/files.feature.js

@@ -0,0 +1,51 @@
+// src/files.feature.ts
+import { defineFeature } from "@contractspec/lib.contracts";
+var FilesFeature = defineFeature({
+  meta: {
+    key: "files",
+    version: "1.0.0",
+    title: "File Management",
+    description: "File storage, attachments, and media processing with presigned URLs",
+    domain: "platform",
+    owners: ["@platform.files"],
+    tags: ["files", "upload", "attachments", "storage"],
+    stability: "stable"
+  },
+  operations: [
+    { key: "file.upload", version: "1.0.0" },
+    { key: "file.update", version: "1.0.0" },
+    { key: "file.delete", version: "1.0.0" },
+    { key: "file.get", version: "1.0.0" },
+    { key: "file.list", version: "1.0.0" },
+    { key: "file.downloadUrl", version: "1.0.0" },
+    { key: "file.presignedUrl.create", version: "1.0.0" },
+    { key: "file.version.create", version: "1.0.0" },
+    { key: "file.version.list", version: "1.0.0" },
+    { key: "attachment.attach", version: "1.0.0" },
+    { key: "attachment.detach", version: "1.0.0" },
+    { key: "attachment.list", version: "1.0.0" }
+  ],
+  events: [
+    { key: "file.uploaded", version: "1.0.0" },
+    { key: "file.updated", version: "1.0.0" },
+    { key: "file.deleted", version: "1.0.0" },
+    { key: "file.version_created", version: "1.0.0" },
+    { key: "attachment.attached", version: "1.0.0" },
+    { key: "attachment.detached", version: "1.0.0" },
+    { key: "upload.session_started", version: "1.0.0" },
+    { key: "upload.session_completed", version: "1.0.0" }
+  ],
+  presentations: [],
+  opToPresentation: [],
+  presentationsTargets: [],
+  capabilities: {
+    provides: [
+      { key: "files", version: "1.0.0" },
+      { key: "attachments", version: "1.0.0" }
+    ],
+    requires: [{ key: "identity", version: "1.0.0" }]
+  }
+});
+export {
+  FilesFeature
+};