@flow-industries/id 0.26.2 → 0.26.4

package/dist/sdk/db/invitations.d.ts

@@ -0,0 +1,310 @@
+export declare const signupPolicy: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "signup_policy";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "signup_policy";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        invitationOnly: import("drizzle-orm/pg-core").PgColumn<{
+            name: "invitation_only";
+            tableName: "signup_policy";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_by";
+            tableName: "signup_policy";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "signup_policy";
+            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 declare const invitation: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "invitation";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "invitation";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        codeHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code_hash";
+            tableName: "invitation";
+            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;
+        }, {}, {}>;
+        inviterId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "inviter_id";
+            tableName: "invitation";
+            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;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "invitation";
+            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;
+        }, {}, {}>;
+        maxUses: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_uses";
+            tableName: "invitation";
+            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;
+        }, {}, {}>;
+        usedCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "used_count";
+            tableName: "invitation";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "invitation";
+            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;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "invitation";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        revokedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "revoked_at";
+            tableName: "invitation";
+            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";
+}>;
+export declare const invitationRedemption: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "invitation_redemption";
+    schema: undefined;
+    columns: {
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "invitation_redemption";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        invitationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "invitation_id";
+            tableName: "invitation_redemption";
+            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;
+        }, {}, {}>;
+        inviterId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "inviter_id";
+            tableName: "invitation_redemption";
+            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;
+        }, {}, {}>;
+        redeemedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "redeemed_at";
+            tableName: "invitation_redemption";
+            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";
+}>;

package/dist/sdk/db/invitations.js

@@ -0,0 +1,42 @@
+import { sql } from "drizzle-orm";
+import { boolean, check, index, integer, pgTable, text, timestamp, } from "drizzle-orm/pg-core";
+import { user } from "./schema";
+export const signupPolicy = pgTable("signup_policy", {
+    id: integer("id").primaryKey(),
+    invitationOnly: boolean("invitation_only").notNull().default(false),
+    updatedBy: text("updated_by").references(() => user.id, {
+        onDelete: "set null",
+    }),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (table) => [check("signup_policy_singleton", sql `${table.id} = 1`)]);
+export const invitation = pgTable("invitation", {
+    id: text("id").primaryKey(),
+    codeHash: text("code_hash").notNull().unique(),
+    inviterId: text("inviter_id").references(() => user.id, {
+        onDelete: "set null",
+    }),
+    createdBy: text("created_by").references(() => user.id, {
+        onDelete: "set null",
+    }),
+    maxUses: integer("max_uses").notNull().default(1),
+    usedCount: integer("used_count").notNull().default(0),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    expiresAt: timestamp("expires_at").notNull(),
+    revokedAt: timestamp("revoked_at"),
+}, (table) => [
+    check("invitation_capacity", sql `${table.maxUses} between 1 and 100 and ${table.usedCount} between 0 and ${table.maxUses}`),
+]);
+export const invitationRedemption = pgTable("invitation_redemption", {
+    userId: text("user_id")
+        .primaryKey()
+        .references(() => user.id, { onDelete: "cascade" }),
+    invitationId: text("invitation_id")
+        .notNull()
+        .references(() => invitation.id),
+    inviterId: text("inviter_id").references(() => user.id, {
+        onDelete: "set null",
+    }),
+    redeemedAt: timestamp("redeemed_at").notNull().defaultNow(),
+}, (table) => [
+    index("invitation_redemption_invitation_idx").on(table.invitationId),
+]);

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

@@ -4951,3 +4951,251 @@ export declare const oauthState: import("drizzle-orm/pg-core").PgTableWithColumn
     };
     dialect: "pg";
 }>;
+export declare const managedPdsOperation: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "managed_pds_operation";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "managed_pds_operation";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        handle: import("drizzle-orm/pg-core").PgColumn<{
+            name: "handle";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        inviteReference: import("drizzle-orm/pg-core").PgColumn<{
+            name: "invite_reference";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        state: import("drizzle-orm/pg-core").PgColumn<{
+            name: "state";
+            tableName: "managed_pds_operation";
+            dataType: "string";
+            columnType: "PgText";
+            data: import("../types").ManagedPdsState;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: import("../types").ManagedPdsState;
+        }>;
+        did: import("drizzle-orm/pg-core").PgColumn<{
+            name: "did";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        pdsEndpoint: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pds_endpoint";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        identityVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "identity_version";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        fence: import("drizzle-orm/pg-core").PgColumn<{
+            name: "fence";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        leaseUntil: import("drizzle-orm/pg-core").PgColumn<{
+            name: "lease_until";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        failureCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failure_code";
+            tableName: "managed_pds_operation";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "managed_pds_operation";
+            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: "managed_pds_operation";
+            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 { invitation, invitationRedemption, signupPolicy } from "./invitations";

package/dist/sdk/db/schema.js

@@ -876,3 +876,28 @@ export const oauthState = pgTable("oauth_state", {
     data: text("data").notNull(),
     expiresAt: timestamp("expires_at").notNull(),
 }, (table) => [primaryKey({ columns: [table.providerId, table.id] })]);
+export const managedPdsOperation = pgTable("managed_pds_operation", {
+    id: text("id").primaryKey(),
+    userId: text("user_id").references(() => user.id, { onDelete: "set null" }),
+    handle: text("handle").notNull(),
+    inviteReference: text("invite_reference").notNull(),
+    state: text("state")
+        .$type()
+        .notNull()
+        .default("queued"),
+    did: text("did"),
+    pdsEndpoint: text("pds_endpoint").notNull(),
+    identityVersion: integer("identity_version").notNull().default(1),
+    fence: integer("fence").notNull().default(0),
+    attempts: integer("attempts").notNull().default(0),
+    leaseUntil: timestamp("lease_until"),
+    failureCode: text("failure_code"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (table) => [
+    uniqueIndex("managed_pds_user_idx").on(table.userId),
+    uniqueIndex("managed_pds_handle_idx").on(table.handle),
+    uniqueIndex("managed_pds_did_idx").on(table.did),
+    index("managed_pds_work_idx").on(table.state, table.leaseUntil),
+]);
+export { invitation, invitationRedemption, signupPolicy } from "./invitations";

package/dist/sdk/session-view.d.ts

@@ -0,0 +1,15 @@
+import type { SessionUser } from "./types";
+/** The audience a session was minted for. */
+export declare const audienceOf: <T>(session: T) => string | undefined;
+/** A session's own id. */
+export declare const sessionIdOf: <T>(session: T) => string | undefined;
+/** Whether the account is a guest. Absent means "not a guest". */
+export declare const isGuestOf: <T>(user: T) => boolean;
+/** The account's username. */
+export declare const usernameOf: <T>(user: T) => string | undefined;
+/**
+ * better-auth types `session.user` from its own base schema. Flow declares the extra columns
+ * through `additionalFields`, so every user row this server reads or writes carries them; the
+ * assertion names that configured shape rather than guessing at one.
+ */
+export declare function sessionUserOf<T>(user: T): SessionUser;

package/dist/sdk/session-view.js

@@ -0,0 +1,32 @@
+/**
+ * better-auth types `User` and `Session` from its own schema, so the fields Flow adds through
+ * `additionalFields` (audience, isGuest, username, walletAddress) are absent from those types.
+ *
+ * These read the added fields off the value without asserting a shape onto it, so a missing or
+ * wrongly-typed field answers `undefined` rather than becoming a lie the compiler believes.
+ * `String(x) === x` holds only for string primitives, which is the check without a `typeof`.
+ */
+function textField(value, key) {
+    const found = Object.entries(Object(value)).find(([k]) => k === key)?.[1];
+    return String(found) === found ? found : undefined;
+}
+function boolField(value, key) {
+    return Object.entries(Object(value)).find(([k]) => k === key)?.[1] === true;
+}
+/** The audience a session was minted for. */
+export const audienceOf = (session) => textField(session, "audience");
+/** A session's own id. */
+export const sessionIdOf = (session) => textField(session, "id");
+/** Whether the account is a guest. Absent means "not a guest". */
+export const isGuestOf = (user) => boolField(user, "isGuest");
+/** The account's username. */
+export const usernameOf = (user) => textField(user, "username");
+/**
+ * better-auth types `session.user` from its own base schema. Flow declares the extra columns
+ * through `additionalFields`, so every user row this server reads or writes carries them; the
+ * assertion names that configured shape rather than guessing at one.
+ */
+export function sessionUserOf(user) {
+    // SAFETY: the fields are declared in the plugin config; see the doc comment.
+    return user;
+}