@shipfox/api-workspaces 2.0.0

package/dist/db/schema/invitations.js

@@ -0,0 +1,47 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { workspaces } from './workspaces.js';
+export const invitations = pgTable('invitations', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull().references(()=>workspaces.id, {
+        onDelete: 'cascade'
+    }),
+    email: text('email').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    expiresAt: timestamp('expires_at', {
+        withTimezone: true
+    }).notNull(),
+    acceptedAt: timestamp('accepted_at', {
+        withTimezone: true
+    }),
+    acceptedByUserId: uuid('accepted_by_user_id'),
+    invitedByUserId: uuid('invited_by_user_id').notNull(),
+    invitedByDisplay: text('invited_by_display'),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('workspaces_invitations_hashed_token_unique').on(table.hashedToken),
+        index('workspaces_invitations_workspace_email_idx').on(table.workspaceId, table.email)
+    ]);
+export function toInvitation(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspaceId,
+        email: row.email,
+        hashedToken: row.hashedToken,
+        expiresAt: row.expiresAt,
+        acceptedAt: row.acceptedAt,
+        acceptedByUserId: row.acceptedByUserId,
+        invitedByUserId: row.invitedByUserId,
+        invitedByDisplay: row.invitedByDisplay,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=invitations.js.map

package/dist/db/schema/invitations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/invitations.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {Invitation} from '#core/entities/invitation.js';\nimport {pgTable} from './common.js';\nimport {workspaces} from './workspaces.js';\n\nexport const invitations = pgTable(\n  'invitations',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id')\n      .notNull()\n      .references(() => workspaces.id, {onDelete: 'cascade'}),\n    email: text('email').notNull(),\n    hashedToken: text('hashed_token').notNull(),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    acceptedAt: timestamp('accepted_at', {withTimezone: true}),\n    acceptedByUserId: uuid('accepted_by_user_id'),\n    invitedByUserId: uuid('invited_by_user_id').notNull(),\n    invitedByDisplay: text('invited_by_display'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('workspaces_invitations_hashed_token_unique').on(table.hashedToken),\n    index('workspaces_invitations_workspace_email_idx').on(table.workspaceId, table.email),\n  ],\n);\n\nexport type InvitationDb = typeof invitations.$inferSelect;\nexport type InvitationCreateDb = typeof invitations.$inferInsert;\n\nexport function toInvitation(row: InvitationDb): Invitation {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    email: row.email,\n    hashedToken: row.hashedToken,\n    expiresAt: row.expiresAt,\n    acceptedAt: row.acceptedAt,\n    acceptedByUserId: row.acceptedByUserId,\n    invitedByUserId: row.invitedByUserId,\n    invitedByDisplay: row.invitedByDisplay,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","workspaces","invitations","id","workspaceId","notNull","references","onDelete","email","hashedToken","expiresAt","withTimezone","acceptedAt","acceptedByUserId","invitedByUserId","invitedByDisplay","createdAt","defaultNow","updatedAt","table","on","toInvitation","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE9E,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,UAAU,QAAO,kBAAkB;AAE3C,OAAO,MAAMC,cAAcF,QACzB,eACA;IACEG,IAAIT;IACJU,aAAaL,KAAK,gBACfM,OAAO,GACPC,UAAU,CAAC,IAAML,WAAWE,EAAE,EAAE;QAACI,UAAU;IAAS;IACvDC,OAAOZ,KAAK,SAASS,OAAO;IAC5BI,aAAab,KAAK,gBAAgBS,OAAO;IACzCK,WAAWb,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGN,OAAO;IAChEO,YAAYf,UAAU,eAAe;QAACc,cAAc;IAAI;IACxDE,kBAAkBd,KAAK;IACvBe,iBAAiBf,KAAK,sBAAsBM,OAAO;IACnDU,kBAAkBnB,KAAK;IACvBoB,WAAWnB,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGN,OAAO,GAAGY,UAAU;IAC7EC,WAAWrB,UAAU,cAAc;QAACc,cAAc;IAAI,GAAGN,OAAO,GAAGY,UAAU;AAC/E,GACA,CAACE,QAAU;QACTrB,YAAY,8CAA8CsB,EAAE,CAACD,MAAMV,WAAW;QAC9Ed,MAAM,8CAA8CyB,EAAE,CAACD,MAAMf,WAAW,EAAEe,MAAMX,KAAK;KACtF,EACD;AAKF,OAAO,SAASa,aAAaC,GAAiB;IAC5C,OAAO;QACLnB,IAAImB,IAAInB,EAAE;QACVC,aAAakB,IAAIlB,WAAW;QAC5BI,OAAOc,IAAId,KAAK;QAChBC,aAAaa,IAAIb,WAAW;QAC5BC,WAAWY,IAAIZ,SAAS;QACxBE,YAAYU,IAAIV,UAAU;QAC1BC,kBAAkBS,IAAIT,gBAAgB;QACtCC,iBAAiBQ,IAAIR,eAAe;QACpCC,kBAAkBO,IAAIP,gBAAgB;QACtCC,WAAWM,IAAIN,SAAS;QACxBE,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

package/dist/db/schema/memberships.d.ts

@@ -0,0 +1,131 @@
+import type { Membership } from '#core/entities/membership.js';
+export declare const memberships: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "memberships";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "memberships";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "memberships";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userEmail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_email";
+            tableName: "memberships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_name";
+            tableName: "memberships";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "memberships";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "memberships";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "memberships";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type MembershipDb = typeof memberships.$inferSelect;
+export type MembershipCreateDb = typeof memberships.$inferInsert;
+export declare function toMembership(row: MembershipDb): Membership;
+//# sourceMappingURL=memberships.d.ts.map

package/dist/db/schema/memberships.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memberships.d.ts","sourceRoot":"","sources":["../../../src/db/schema/memberships.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,8BAA8B,CAAC;AAI7D,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,WAAW,CAAC,YAAY,CAAC;AAEjE,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,UAAU,CAU1D"}

package/dist/db/schema/memberships.js

@@ -0,0 +1,35 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { index, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { workspaces } from './workspaces.js';
+export const memberships = pgTable('memberships', {
+    id: uuidv7PrimaryKey(),
+    userId: uuid('user_id').notNull(),
+    userEmail: text('user_email').notNull(),
+    userName: text('user_name'),
+    workspaceId: uuid('workspace_id').notNull().references(()=>workspaces.id, {
+        onDelete: 'cascade'
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+}, (table)=>[
+        uniqueIndex('workspaces_memberships_user_workspace_unique').on(table.userId, table.workspaceId),
+        index('workspaces_memberships_workspace_id_idx').on(table.workspaceId)
+    ]);
+export function toMembership(row) {
+    return {
+        id: row.id,
+        userId: row.userId,
+        userEmail: row.userEmail,
+        userName: row.userName,
+        workspaceId: row.workspaceId,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=memberships.js.map

package/dist/db/schema/memberships.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/memberships.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {Membership} from '#core/entities/membership.js';\nimport {pgTable} from './common.js';\nimport {workspaces} from './workspaces.js';\n\nexport const memberships = pgTable(\n  'memberships',\n  {\n    id: uuidv7PrimaryKey(),\n    userId: uuid('user_id').notNull(),\n    userEmail: text('user_email').notNull(),\n    userName: text('user_name'),\n    workspaceId: uuid('workspace_id')\n      .notNull()\n      .references(() => workspaces.id, {onDelete: 'cascade'}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('workspaces_memberships_user_workspace_unique').on(table.userId, table.workspaceId),\n    index('workspaces_memberships_workspace_id_idx').on(table.workspaceId),\n  ],\n);\n\nexport type MembershipDb = typeof memberships.$inferSelect;\nexport type MembershipCreateDb = typeof memberships.$inferInsert;\n\nexport function toMembership(row: MembershipDb): Membership {\n  return {\n    id: row.id,\n    userId: row.userId,\n    userEmail: row.userEmail,\n    userName: row.userName,\n    workspaceId: row.workspaceId,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","index","text","timestamp","uniqueIndex","uuid","pgTable","workspaces","memberships","id","userId","notNull","userEmail","userName","workspaceId","references","onDelete","createdAt","withTimezone","defaultNow","updatedAt","table","on","toMembership","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAE9E,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,UAAU,QAAO,kBAAkB;AAE3C,OAAO,MAAMC,cAAcF,QACzB,eACA;IACEG,IAAIT;IACJU,QAAQL,KAAK,WAAWM,OAAO;IAC/BC,WAAWV,KAAK,cAAcS,OAAO;IACrCE,UAAUX,KAAK;IACfY,aAAaT,KAAK,gBACfM,OAAO,GACPI,UAAU,CAAC,IAAMR,WAAWE,EAAE,EAAE;QAACO,UAAU;IAAS;IACvDC,WAAWd,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGP,OAAO,GAAGQ,UAAU;IAC7EC,WAAWjB,UAAU,cAAc;QAACe,cAAc;IAAI,GAAGP,OAAO,GAAGQ,UAAU;AAC/E,GACA,CAACE,QAAU;QACTjB,YAAY,gDAAgDkB,EAAE,CAACD,MAAMX,MAAM,EAAEW,MAAMP,WAAW;QAC9Fb,MAAM,2CAA2CqB,EAAE,CAACD,MAAMP,WAAW;KACtE,EACD;AAKF,OAAO,SAASS,aAAaC,GAAiB;IAC5C,OAAO;QACLf,IAAIe,IAAIf,EAAE;QACVC,QAAQc,IAAId,MAAM;QAClBE,WAAWY,IAAIZ,SAAS;QACxBC,UAAUW,IAAIX,QAAQ;QACtBC,aAAaU,IAAIV,WAAW;QAC5BG,WAAWO,IAAIP,SAAS;QACxBG,WAAWI,IAAIJ,SAAS;IAC1B;AACF"}

package/dist/db/schema/outbox.d.ts

@@ -0,0 +1,195 @@
+export declare const workspacesOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "outbox";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_type";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orderingKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ordering_key";
+            tableName: "outbox";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core").PgColumn<{
+            name: "payload";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatched_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dispatchAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dispatch_attempts";
+            tableName: "outbox";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        nextDispatchAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "next_dispatch_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchError: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_error";
+            tableName: "outbox";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastDispatchFailedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_dispatch_failed_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deadLetteredAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dead_lettered_at";
+            tableName: "outbox";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=outbox.d.ts.map

package/dist/db/schema/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","sourceRoot":"","sources":["../../../src/db/schema/outbox.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC"}

package/dist/db/schema/outbox.js

@@ -0,0 +1,5 @@
+import { createOutboxTable } from '@shipfox/node-outbox';
+import { pgTable } from './common.js';
+export const workspacesOutbox = createOutboxTable(pgTable);
+
+//# sourceMappingURL=outbox.js.map

package/dist/db/schema/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/outbox.ts"],"sourcesContent":["import {createOutboxTable} from '@shipfox/node-outbox';\nimport {pgTable} from './common.js';\n\nexport const workspacesOutbox = createOutboxTable(pgTable);\n"],"names":["createOutboxTable","pgTable","workspacesOutbox"],"mappings":"AAAA,SAAQA,iBAAiB,QAAO,uBAAuB;AACvD,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,mBAAmBF,kBAAkBC,SAAS"}

package/dist/db/schema/workspaces.d.ts

@@ -0,0 +1,115 @@
+import type { Workspace } from '#core/entities/workspace.js';
+export declare const workspaceStatusEnum: import("drizzle-orm/pg-core").PgEnum<["active", "suspended", "deleted"]>;
+export declare const workspaces: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workspaces";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workspaces";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "workspaces";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workspaces";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "active" | "suspended" | "deleted";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "suspended", "deleted"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        settings: import("drizzle-orm/pg-core").PgColumn<{
+            name: "settings";
+            tableName: "workspaces";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workspaces";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "workspaces";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type WorkspaceDb = typeof workspaces.$inferSelect;
+export type WorkspaceCreateDb = typeof workspaces.$inferInsert;
+export declare function toWorkspace(row: WorkspaceDb): Workspace;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/db/schema/workspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../../src/db/schema/workspaces.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,SAAS,EAAkB,MAAM,6BAA6B,CAAC;AAG5E,eAAO,MAAM,mBAAmB,0EAI9B,CAAC;AAEH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,UAAU,CAAC,YAAY,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG,OAAO,UAAU,CAAC,YAAY,CAAC;AAE/D,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,CASvD"}

package/dist/db/schema/workspaces.js

@@ -0,0 +1,32 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { jsonb, pgEnum, text, timestamp } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+export const workspaceStatusEnum = pgEnum('workspaces_workspace_status', [
+    'active',
+    'suspended',
+    'deleted'
+]);
+export const workspaces = pgTable('workspaces', {
+    id: uuidv7PrimaryKey(),
+    name: text('name').notNull(),
+    status: workspaceStatusEnum('status').notNull().default('active'),
+    settings: jsonb('settings').notNull().default({}),
+    createdAt: timestamp('created_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true
+    }).notNull().defaultNow()
+});
+export function toWorkspace(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        status: row.status,
+        settings: row.settings,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt
+    };
+}
+
+//# sourceMappingURL=workspaces.js.map

package/dist/db/schema/workspaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/workspaces.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {jsonb, pgEnum, text, timestamp} from 'drizzle-orm/pg-core';\nimport type {Workspace, WorkspaceStatus} from '#core/entities/workspace.js';\nimport {pgTable} from './common.js';\n\nexport const workspaceStatusEnum = pgEnum('workspaces_workspace_status', [\n  'active',\n  'suspended',\n  'deleted',\n]);\n\nexport const workspaces = pgTable('workspaces', {\n  id: uuidv7PrimaryKey(),\n  name: text('name').notNull(),\n  status: workspaceStatusEnum('status').notNull().default('active'),\n  settings: jsonb('settings').notNull().default({}),\n  createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n});\n\nexport type WorkspaceDb = typeof workspaces.$inferSelect;\nexport type WorkspaceCreateDb = typeof workspaces.$inferInsert;\n\nexport function toWorkspace(row: WorkspaceDb): Workspace {\n  return {\n    id: row.id,\n    name: row.name,\n    status: row.status as WorkspaceStatus,\n    settings: row.settings as Record<string, unknown>,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","jsonb","pgEnum","text","timestamp","pgTable","workspaceStatusEnum","workspaces","id","name","notNull","status","default","settings","createdAt","withTimezone","defaultNow","updatedAt","toWorkspace","row"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,KAAK,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,QAAO,sBAAsB;AAEnE,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,sBAAsBJ,OAAO,+BAA+B;IACvE;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMK,aAAaF,QAAQ,cAAc;IAC9CG,IAAIR;IACJS,MAAMN,KAAK,QAAQO,OAAO;IAC1BC,QAAQL,oBAAoB,UAAUI,OAAO,GAAGE,OAAO,CAAC;IACxDC,UAAUZ,MAAM,YAAYS,OAAO,GAAGE,OAAO,CAAC,CAAC;IAC/CE,WAAWV,UAAU,cAAc;QAACW,cAAc;IAAI,GAAGL,OAAO,GAAGM,UAAU;IAC7EC,WAAWb,UAAU,cAAc;QAACW,cAAc;IAAI,GAAGL,OAAO,GAAGM,UAAU;AAC/E,GAAG;AAKH,OAAO,SAASE,YAAYC,GAAgB;IAC1C,OAAO;QACLX,IAAIW,IAAIX,EAAE;QACVC,MAAMU,IAAIV,IAAI;QACdE,QAAQQ,IAAIR,MAAM;QAClBE,UAAUM,IAAIN,QAAQ;QACtBC,WAAWK,IAAIL,SAAS;QACxBG,WAAWE,IAAIF,SAAS;IAC1B;AACF"}

package/dist/db/workspaces.d.ts

@@ -0,0 +1,20 @@
+import type { Workspace, WorkspaceStatus } from '#core/entities/workspace.js';
+export interface CreateWorkspaceParams {
+    name: string;
+}
+export declare function createWorkspace(params: CreateWorkspaceParams): Promise<Workspace>;
+export interface UpdateWorkspaceParams {
+    id: string;
+    name?: string | undefined;
+    status?: WorkspaceStatus | undefined;
+    settings?: Record<string, unknown> | undefined;
+}
+export declare function updateWorkspace(params: UpdateWorkspaceParams): Promise<Workspace | undefined>;
+export declare function getWorkspaceById(id: string): Promise<Workspace | undefined>;
+export interface WorkspaceServiceMetrics {
+    activeWorkspaces: number;
+    memberships: number;
+    openInvitations: number;
+}
+export declare function getWorkspaceServiceMetrics(): Promise<WorkspaceServiceMetrics>;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/db/workspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../src/db/workspaces.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAO5E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC,CAYvF;AAED,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAChD;AAED,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAehC;AAED,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAKjF;AAED,MAAM,WAAW,uBAAuB;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAenF"}