@absolutejs/artifacts 0.0.5 → 0.1.0

package/README.md

@@ -87,6 +87,27 @@ const history = await artifacts.listRevisions("owner-123", page.id);
 const restored = await artifacts.restore("owner-123", page.id, 1);
 ```
 
+## Production persistence
+
+Use the package-owned Drizzle schema on PostgreSQL, including Neon. The store
+atomically writes the current artifact, immutable revision, and lifecycle
+outbox events. It also persists per-revision indexing state and fences every
+artifact read and mutation by owner.
+
+```ts
+import {
+  artifactDrizzleSchema,
+  createDrizzleArtifactStore,
+} from "@absolutejs/artifacts/drizzle";
+
+const store = createDrizzleArtifactStore({ db });
+```
+
+Export `artifactDrizzleSchema` from your application's Drizzle schema so its
+normal migration workflow owns the four tables. Insert and select TypeBoxes
+generated directly from those tables are exported from the same entry point;
+hosts should reuse them instead of redefining database row schemas.
+
 ## File-backed artifact kinds
 
 Use the bundled definitions directly or compose them with application-specific

package/dist/drizzle.js

@@ -0,0 +1,245 @@
+// @bun
+// src/drizzle.ts
+import { and, asc, desc, eq, isNotNull, isNull } from "drizzle-orm";
+import {
+  customType,
+  index,
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-typebox";
+var recordJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var revisionJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var eventJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var indexingJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var artifactRecords = pgTable("artifact_records", {
+  document: recordJsonb().notNull(),
+  id: text().primaryKey(),
+  kind: text().notNull(),
+  ownerId: text("owner_id").notNull(),
+  revision: integer().notNull(),
+  status: text().notNull(),
+  updatedAt: timestamp("updated_at", {
+    mode: "string",
+    withTimezone: true
+  }).notNull()
+}, (table) => [
+  index("artifact_records_owner_updated_idx").on(table.ownerId, table.updatedAt.desc()),
+  index("artifact_records_owner_kind_idx").on(table.ownerId, table.kind)
+]);
+var artifactRevisions = pgTable("artifact_revisions", {
+  artifactId: text("artifact_id").notNull().references(() => artifactRecords.id),
+  document: revisionJsonb().notNull(),
+  ownerId: text("owner_id").notNull(),
+  revision: integer().notNull()
+}, (table) => [
+  primaryKey({
+    columns: [table.artifactId, table.revision],
+    name: "artifact_revisions_pkey"
+  }),
+  index("artifact_revisions_owner_idx").on(table.ownerId, table.artifactId, table.revision.desc())
+]);
+var artifactEvents = pgTable("artifact_events", {
+  artifactId: text("artifact_id").notNull().references(() => artifactRecords.id),
+  createdAt: timestamp("created_at", {
+    mode: "string",
+    withTimezone: true
+  }).notNull(),
+  document: eventJsonb().notNull(),
+  id: text().primaryKey(),
+  ownerId: text("owner_id").notNull(),
+  processedAt: timestamp("processed_at", {
+    mode: "string",
+    withTimezone: true
+  }),
+  type: text().notNull()
+}, (table) => [
+  index("artifact_events_outbox_idx").on(table.processedAt, table.createdAt),
+  index("artifact_events_artifact_idx").on(table.ownerId, table.artifactId, table.createdAt)
+]);
+var artifactIndexingStates = pgTable("artifact_indexing_states", {
+  artifactId: text("artifact_id").primaryKey().references(() => artifactRecords.id),
+  document: indexingJsonb().notNull(),
+  ownerId: text("owner_id").notNull(),
+  revision: integer().notNull(),
+  status: text().notNull(),
+  updatedAt: timestamp("updated_at", {
+    mode: "string",
+    withTimezone: true
+  }).notNull()
+});
+var artifactDrizzleSchema = {
+  artifactEvents,
+  artifactIndexingStates,
+  artifactRecords,
+  artifactRevisions
+};
+var ArtifactRecordInsertSchema = createInsertSchema(artifactRecords);
+var ArtifactRecordSelectSchema = createSelectSchema(artifactRecords);
+var ArtifactRevisionInsertSchema = createInsertSchema(artifactRevisions);
+var ArtifactRevisionSelectSchema = createSelectSchema(artifactRevisions);
+var ArtifactEventInsertSchema = createInsertSchema(artifactEvents);
+var ArtifactEventSelectSchema = createSelectSchema(artifactEvents);
+var ArtifactIndexingStateInsertSchema = createInsertSchema(artifactIndexingStates);
+var ArtifactIndexingStateSelectSchema = createSelectSchema(artifactIndexingStates);
+var eventRows = (events) => events.map((event) => ({
+  artifactId: event.artifactId,
+  createdAt: event.createdAt,
+  document: event,
+  id: event.id,
+  ownerId: event.ownerId,
+  processedAt: event.processedAt,
+  type: event.type
+}));
+var assertEventsBelongToArtifact = (record, events) => {
+  if (events.some((event) => event.artifactId !== record.id || event.ownerId !== record.ownerId))
+    throw new Error("Artifact events must belong to the persisted artifact");
+};
+var recordRow = (record) => ({
+  document: record,
+  id: record.id,
+  kind: record.kind,
+  ownerId: record.ownerId,
+  revision: record.revision,
+  status: record.status,
+  updatedAt: record.updatedAt
+});
+var recordUpdate = (record) => ({
+  document: record,
+  kind: record.kind,
+  ownerId: record.ownerId,
+  revision: record.revision,
+  status: record.status,
+  updatedAt: record.updatedAt
+});
+var revisionRow = (record) => ({
+  artifactId: record.id,
+  document: record,
+  ownerId: record.ownerId,
+  revision: record.revision
+});
+var createDrizzleArtifactStore = (options) => ({
+  create: (record, events = []) => options.db.transaction(async (transaction) => {
+    assertEventsBelongToArtifact(record, events);
+    await transaction.insert(artifactRecords).values(recordRow(record));
+    await transaction.insert(artifactRevisions).values(revisionRow(record));
+    if (events.length > 0)
+      await transaction.insert(artifactEvents).values(eventRows(events));
+  }),
+  get: async (ownerId, artifactId) => {
+    const [row] = await options.db.select({ document: artifactRecords.document }).from(artifactRecords).where(and(eq(artifactRecords.id, artifactId), eq(artifactRecords.ownerId, ownerId))).limit(1);
+    return row?.document ?? null;
+  },
+  getIndexingState: async (ownerId, artifactId) => {
+    const [row] = await options.db.select({ document: artifactIndexingStates.document }).from(artifactIndexingStates).where(and(eq(artifactIndexingStates.artifactId, artifactId), eq(artifactIndexingStates.ownerId, ownerId))).limit(1);
+    return row?.document ?? null;
+  },
+  getRevision: async (ownerId, artifactId, revision) => {
+    const [row] = await options.db.select({ document: artifactRevisions.document }).from(artifactRevisions).where(and(eq(artifactRevisions.artifactId, artifactId), eq(artifactRevisions.ownerId, ownerId), eq(artifactRevisions.revision, revision))).limit(1);
+    return row?.document ?? null;
+  },
+  list: async (ownerId, query = {}) => {
+    const conditions = [eq(artifactRecords.ownerId, ownerId)];
+    if (query.kind)
+      conditions.push(eq(artifactRecords.kind, query.kind));
+    if (query.status)
+      conditions.push(eq(artifactRecords.status, query.status));
+    const statement = options.db.select({ document: artifactRecords.document }).from(artifactRecords).where(and(...conditions)).orderBy(desc(artifactRecords.updatedAt));
+    const rows = query.limit === undefined ? await statement : await statement.limit(query.limit);
+    return rows.map(({ document }) => document);
+  },
+  listEvents: async (query = {}) => {
+    const conditions = [];
+    if (query.processed !== undefined)
+      conditions.push(query.processed ? isNotNull(artifactEvents.processedAt) : isNull(artifactEvents.processedAt));
+    if (query.type)
+      conditions.push(eq(artifactEvents.type, query.type));
+    const statement = options.db.select({
+      document: artifactEvents.document,
+      processedAt: artifactEvents.processedAt
+    }).from(artifactEvents).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(asc(artifactEvents.createdAt));
+    const rows = query.limit === undefined ? await statement : await statement.limit(query.limit);
+    return rows.map(({ document, processedAt }) => ({
+      ...document,
+      ...processedAt ? { processedAt: new Date(processedAt).toISOString() } : {}
+    }));
+  },
+  listReferencedAssetIds: async () => {
+    const rows = await options.db.select({ document: artifactRevisions.document }).from(artifactRevisions);
+    return [
+      ...new Set(rows.flatMap(({ document }) => document.assets.map(({ id }) => id)))
+    ];
+  },
+  listRevisions: async (ownerId, artifactId) => (await options.db.select({ document: artifactRevisions.document }).from(artifactRevisions).where(and(eq(artifactRevisions.artifactId, artifactId), eq(artifactRevisions.ownerId, ownerId))).orderBy(desc(artifactRevisions.revision))).map(({ document }) => document),
+  markEventProcessed: async (eventId, processedAt) => (await options.db.update(artifactEvents).set({ processedAt }).where(eq(artifactEvents.id, eventId)).returning({ id: artifactEvents.id })).length === 1,
+  putIndexingState: (ownerId, state, events = []) => options.db.transaction(async (transaction) => {
+    assertEventsBelongToArtifact({ id: state.artifactId, ownerId }, events);
+    const [artifact] = await transaction.select({ id: artifactRecords.id }).from(artifactRecords).where(and(eq(artifactRecords.id, state.artifactId), eq(artifactRecords.ownerId, ownerId))).limit(1);
+    if (!artifact)
+      throw new Error("Artifact not found");
+    await transaction.insert(artifactIndexingStates).values({
+      artifactId: state.artifactId,
+      document: state,
+      ownerId,
+      revision: state.revision,
+      status: state.status,
+      updatedAt: state.updatedAt
+    }).onConflictDoUpdate({
+      set: {
+        document: state,
+        ownerId,
+        revision: state.revision,
+        status: state.status,
+        updatedAt: state.updatedAt
+      },
+      target: artifactIndexingStates.artifactId
+    });
+    if (events.length > 0)
+      await transaction.insert(artifactEvents).values(eventRows(events));
+  }),
+  save: (record, expectedRevision, events = []) => options.db.transaction(async (transaction) => {
+    assertEventsBelongToArtifact(record, events);
+    const updated = await transaction.update(artifactRecords).set(recordUpdate(record)).where(and(eq(artifactRecords.id, record.id), eq(artifactRecords.ownerId, record.ownerId), eq(artifactRecords.revision, expectedRevision))).returning({ id: artifactRecords.id });
+    if (updated.length !== 1)
+      return false;
+    await transaction.insert(artifactRevisions).values(revisionRow(record));
+    if (events.length > 0)
+      await transaction.insert(artifactEvents).values(eventRows(events));
+    return true;
+  })
+});
+export {
+  createDrizzleArtifactStore,
+  artifactRevisions,
+  artifactRecords,
+  artifactIndexingStates,
+  artifactEvents,
+  artifactDrizzleSchema,
+  ArtifactRevisionSelectSchema,
+  ArtifactRevisionInsertSchema,
+  ArtifactRecordSelectSchema,
+  ArtifactRecordInsertSchema,
+  ArtifactIndexingStateSelectSchema,
+  ArtifactIndexingStateInsertSchema,
+  ArtifactEventSelectSchema,
+  ArtifactEventInsertSchema
+};

package/dist/manifest.js

@@ -14,6 +14,10 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var defineImplementation = () => (implementation) => {
+  const defined = implementation;
+  return defined;
+};
 var defineManifest = () => (manifest) => manifest;
 var literal = (value) => value;
 var RUNTIME_KIND = literal("runtime");
@@ -5986,13 +5990,63 @@ var manifest = defineManifest()({
     name: "@absolutejs/artifacts",
     tagline: "Give everything your AI makes a real lifecycle."
   },
+  implements: [
+    defineImplementation()({
+      contract: "artifacts/store",
+      factory: "createMemoryArtifactStore",
+      from: "@absolutejs/artifacts",
+      title: "In memory (development only \u2014 history resets on restart)",
+      wiring: {
+        code: "createMemoryArtifactStore()",
+        imports: [
+          {
+            from: "@absolutejs/artifacts",
+            names: ["createMemoryArtifactStore"]
+          }
+        ]
+      }
+    }),
+    defineImplementation()({
+      contract: "artifacts/store",
+      factory: "createDrizzleArtifactStore",
+      from: "@absolutejs/artifacts/drizzle",
+      requires: {
+        peers: [
+          {
+            name: "drizzle-orm",
+            range: ">=1.0.0-rc.4 <2",
+            reason: "Typed artifact revisions, indexing state, and transactional outbox persistence"
+          }
+        ],
+        services: [
+          {
+            description: "Artifact lifecycle and revision database",
+            id: "postgres"
+          }
+        ]
+      },
+      title: "Drizzle Postgres (production, including Neon)",
+      wiring: {
+        code: "createDrizzleArtifactStore({ db })",
+        imports: [
+          {
+            from: "@absolutejs/artifacts/drizzle",
+            names: ["createDrizzleArtifactStore"]
+          }
+        ]
+      }
+    })
+  ],
   settings: Type2.Object({}),
   slots: {
-    service: {
+    store: {
       configPath: "$self",
-      contract: "artifacts/service",
-      description: "The host-configured artifact service",
-      known: [],
+      contract: "artifacts/store",
+      description: "Where current artifacts, immutable revisions, indexing state, and transactional outbox events live",
+      known: [
+        "@absolutejs/artifacts#createMemoryArtifactStore",
+        "@absolutejs/artifacts#drizzle"
+      ],
       required: true
     }
   },
@@ -6090,7 +6144,7 @@ var manifest = defineManifest()({
           "\t}",
           "});",
           "",
-          "const artifactStore = createMemoryArtifactStore();",
+          "const artifactStore = ${slot.store};",
           "const artifactService = createArtifactService({",
           "\tregistry: artifactRegistry,",
           "\tstore: artifactStore",
@@ -6100,11 +6154,7 @@ var manifest = defineManifest()({
         imports: [
           {
             from: "@absolutejs/artifacts",
-            names: [
-              "createArtifactService",
-              "createMemoryArtifactStore",
-              "defineArtifactRegistry"
-            ]
+            names: ["createArtifactService", "defineArtifactRegistry"]
           },
           { from: "@sinclair/typebox", names: ["Type"] }
         ],

package/dist/manifest.json

@@ -8,16 +8,70 @@
 		"name": "@absolutejs/artifacts",
 		"tagline": "Give everything your AI makes a real lifecycle."
 	},
+	"implements": [
+		{
+			"contract": "artifacts/store",
+			"factory": "createMemoryArtifactStore",
+			"from": "@absolutejs/artifacts",
+			"title": "In memory (development only — history resets on restart)",
+			"wiring": {
+				"code": "createMemoryArtifactStore()",
+				"imports": [
+					{
+						"from": "@absolutejs/artifacts",
+						"names": [
+							"createMemoryArtifactStore"
+						]
+					}
+				]
+			}
+		},
+		{
+			"contract": "artifacts/store",
+			"factory": "createDrizzleArtifactStore",
+			"from": "@absolutejs/artifacts/drizzle",
+			"requires": {
+				"peers": [
+					{
+						"name": "drizzle-orm",
+						"range": ">=1.0.0-rc.4 <2",
+						"reason": "Typed artifact revisions, indexing state, and transactional outbox persistence"
+					}
+				],
+				"services": [
+					{
+						"description": "Artifact lifecycle and revision database",
+						"id": "postgres"
+					}
+				]
+			},
+			"title": "Drizzle Postgres (production, including Neon)",
+			"wiring": {
+				"code": "createDrizzleArtifactStore({ db })",
+				"imports": [
+					{
+						"from": "@absolutejs/artifacts/drizzle",
+						"names": [
+							"createDrizzleArtifactStore"
+						]
+					}
+				]
+			}
+		}
+	],
 	"settings": {
 		"type": "object",
 		"properties": {}
 	},
 	"slots": {
-		"service": {
+		"store": {
 			"configPath": "$self",
-			"contract": "artifacts/service",
-			"description": "The host-configured artifact service",
-			"known": [],
+			"contract": "artifacts/store",
+			"description": "Where current artifacts, immutable revisions, indexing state, and transactional outbox events live",
+			"known": [
+				"@absolutejs/artifacts#createMemoryArtifactStore",
+				"@absolutejs/artifacts#drizzle"
+			],
 			"required": true
 		}
 	},
@@ -26,13 +80,12 @@
 			"description": "Define structured artifact kinds, provide a store, and create the lifecycle service. Add a publisher only when your host supports public access.",
 			"id": "default",
 			"server": {
-				"code": "const artifactRegistry = defineArtifactRegistry({\n\tpage: {\n\t\tcapabilities: ['archive', 'edit', 'preview', 'publish'],\n\t\tcontent: Type.Object({ blocks: Type.Array(Type.Unknown()) }),\n\t\tlabel: 'Page'\n\t}\n});\n\nconst artifactStore = createMemoryArtifactStore();\nconst artifactService = createArtifactService({\n\tregistry: artifactRegistry,\n\tstore: artifactStore\n});",
+				"code": "const artifactRegistry = defineArtifactRegistry({\n\tpage: {\n\t\tcapabilities: ['archive', 'edit', 'preview', 'publish'],\n\t\tcontent: Type.Object({ blocks: Type.Array(Type.Unknown()) }),\n\t\tlabel: 'Page'\n\t}\n});\n\nconst artifactStore = ${slot.store};\nconst artifactService = createArtifactService({\n\tregistry: artifactRegistry,\n\tstore: artifactStore\n});",
 				"imports": [
 					{
 						"from": "@absolutejs/artifacts",
 						"names": [
 							"createArtifactService",
-							"createMemoryArtifactStore",
 							"defineArtifactRegistry"
 						]
 					},