@getstrata/bootstrap 0.1.0 → 0.1.1

package/dist/bootstrap/web/session.d.ts

@@ -2,6 +2,7 @@ export interface SessionUser {
     id: number;
     name: string;
     email: string;
+    learn_subscriber?: boolean;
 }
 type SqlClient = {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;
@@ -14,6 +15,7 @@ export declare class CookieSessionStore {
     constructor(sql: SqlClient, secret: string, cookieName?: string, maxAgeSeconds?: number);
     cookieHeader(_user: SessionUser, sessionId: string): string;
     clearCookieHeader(): string;
+    private withSecureFlag;
     create(user: SessionUser): Promise<string>;
     destroy(sessionId: string): Promise<void>;
     read(request: Request): Promise<SessionUser | null>;

package/dist/core/auth/abilityChecker.d.ts

@@ -0,0 +1,6 @@
+import type { AuthUser } from "./authContext";
+interface AbilityChecker {
+    tokenCan(user: AuthUser | null, ability: string): boolean;
+    requireAbility(user: AuthUser | null, ability: string): void;
+}
+export type { AbilityChecker };

package/dist/core/auth/policy.d.ts

@@ -9,7 +9,7 @@ declare class PolicyGate {
     constructor();
     private readonly policies;
     register(resource: string, policy: Policy): void;
-    allows(resource: string, action: keyof Policy, user?: unknown, model?: unknown): boolean;
-    authorize(resource: string, action: keyof Policy, user?: unknown, model?: unknown): void;
+    allows(resource: string, action: string, user?: unknown, model?: unknown): boolean;
+    authorize(resource: string, action: string, user?: unknown, model?: unknown): void;
 }
 export { Policy, PolicyGate };

package/dist/core/database/baseRepository.d.ts

@@ -1,5 +1,6 @@
 import { type PaginatedResult } from "../pagination/index.ts";
 import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
+import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
 interface DatabaseConnection {
@@ -27,6 +28,8 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     withConnection(connection: DatabaseConnection): this;
+    getConnection(): DatabaseConnection;
+    query(where?: QueryWhere<TEntity>): RepositoryQuery<TEntity, PrimaryKey>;
     protected findWhere(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
     protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): Promise<number>;
     protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
@@ -36,9 +39,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
         value: TEntity[K] | null;
         count: number;
     }>>;
-    protected findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
-    protected loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
-    protected loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
+    findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
+    loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
 }
 export default BaseRepository;
 export type { DatabaseConnection };

package/dist/core/database/boundConnection.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseConnection } from "./baseRepository";
+declare function bindDatabaseConnection(connection: DatabaseConnection): void;
+declare function getBoundDatabaseConnection(): DatabaseConnection | null;
+declare function resetBoundDatabaseConnection(): void;
+export { bindDatabaseConnection, getBoundDatabaseConnection, resetBoundDatabaseConnection };

package/dist/core/database/index.d.ts

@@ -5,6 +5,7 @@ export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
 export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, } from "./query.ts";
 export type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
 export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "./relationships.ts";
+export { RepositoryQuery } from "./repositoryQuery.ts";
 export type { TableDefinition } from "./table.ts";
 export { defineTable } from "./table.ts";
 export { runInTransaction } from "./transaction.ts";

package/dist/core/database/query.d.ts

@@ -24,6 +24,7 @@ declare function buildProjectionQuery<TEntity>(table: TableDefinition<TEntity>,
     text: string;
     params: unknown[];
 };
+declare function assertSafeProjectionExpression(expression: string): void;
 declare function buildGroupedCountQuery<TEntity, K extends keyof TEntity & string>(table: TableDefinition<TEntity>, column: K, where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): {
     text: string;
     params: unknown[];
@@ -48,4 +49,4 @@ declare function buildDeleteByIdQuery<TEntity, PrimaryKey extends keyof TEntity
     text: string;
     params: unknown[];
 };
-export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, };
+export { assertSafeProjectionExpression, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, };

package/dist/core/database/repositoryConnection.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseConnection } from "./baseRepository";
+declare function resolveRepositoryConnection(): DatabaseConnection;
+declare const repositoryConnection: DatabaseConnection;
+export { repositoryConnection, resolveRepositoryConnection };

package/dist/core/database/repositoryQuery.d.ts

@@ -0,0 +1,20 @@
+import type BaseRepository from "./baseRepository.ts";
+import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
+import type { QueryOptions, QueryWhere } from "./types.ts";
+type LoadedRow = Record<string, unknown>;
+declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    private readonly repository;
+    private whereClause;
+    private queryOptions;
+    private readonly eagerLoads;
+    constructor(repository: BaseRepository<TEntity, PrimaryKey>, whereClause?: QueryWhere<TEntity>, queryOptions?: Omit<QueryOptions<TEntity>, "where">);
+    where(where: QueryWhere<TEntity>): this;
+    orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
+    limit(limit: number): this;
+    withHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
+    withBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): this;
+    get(): Promise<Array<TEntity & LoadedRow>>;
+    first(): Promise<(TEntity & LoadedRow) | null>;
+    private attach;
+}
+export { RepositoryQuery };

package/dist/core/http/requireAbilityMiddleware.d.ts

@@ -1,4 +1,4 @@
-import type TokenService from "../../modules/user/tokenService";
+import type { AbilityChecker } from "../auth/abilityChecker";
 import type { Middleware } from "./middleware";
-declare function createRequireAbilityMiddleware(tokenService: TokenService): (ability: string) => Middleware;
+declare function createRequireAbilityMiddleware(abilityChecker: AbilityChecker): (ability: string) => Middleware;
 export { createRequireAbilityMiddleware };

package/dist/index.js

@@ -951,12 +951,12 @@ async function requestIdMiddleware(request, next) {
 }
 
 // ../../src/core/http/requireAbilityMiddleware.ts
-function createRequireAbilityMiddleware(tokenService) {
+function createRequireAbilityMiddleware(abilityChecker) {
   return (ability) => {
     return async (_request, next) => {
       const user = currentAuthUser();
       try {
-        tokenService.requireAbility(user, ability);
+        abilityChecker.requireAbility(user, ability);
       } catch (error) {
         if (error instanceof ForbiddenError) {
           return Response.json({ error: error.message }, { status: error.status });
@@ -1508,8 +1508,8 @@ class HttpKernel {
   }
   wrapWebAbility(ability, handler) {
     const auth = this.dependencies.container.resolve(CORE_AUTH_TOKEN);
-    const tokenService = this.dependencies.container.resolve(CORE_TOKEN_SERVICE_TOKEN);
-    const requireAbility = createRequireAbilityMiddleware(tokenService);
+    const abilityChecker = this.dependencies.container.resolve(CORE_TOKEN_SERVICE_TOKEN);
+    const requireAbility = createRequireAbilityMiddleware(abilityChecker);
     const middleware = [createRequireWebAuthMiddleware(auth), requireAbility(ability)];
     return withMiddleware(...middleware)(handler);
   }
@@ -1532,8 +1532,8 @@ class HttpKernel {
     return withMiddleware(...middleware)(handler);
   }
   wrapAbility(ability, handler) {
-    const tokenService = this.dependencies.container.resolve(CORE_TOKEN_SERVICE_TOKEN);
-    const requireAbility = createRequireAbilityMiddleware(tokenService);
+    const abilityChecker = this.dependencies.container.resolve(CORE_TOKEN_SERVICE_TOKEN);
+    const requireAbility = createRequireAbilityMiddleware(abilityChecker);
     const middleware = [...this.group("authenticated"), requireAbility(ability)];
     return withMiddleware(...middleware)(handler);
   }
@@ -1670,10 +1670,16 @@ class CookieSessionStore {
   }
   cookieHeader(_user, sessionId) {
     const payload = `${sessionId}.${this.sign(sessionId)}`;
-    return `${this.cookieName}=${payload}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${this.maxAgeSeconds}`;
+    return this.withSecureFlag(`${this.cookieName}=${payload}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${this.maxAgeSeconds}`);
   }
   clearCookieHeader() {
-    return `${this.cookieName}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`;
+    return this.withSecureFlag(`${this.cookieName}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`);
+  }
+  withSecureFlag(header) {
+    if (true) {
+      return header;
+    }
+    return header.includes("Secure") ? header : `${header}; Secure`;
   }
   async create(user) {
     const id = randomBytes3(32).toString("hex");
@@ -1697,14 +1703,19 @@ class CookieSessionStore {
     if (!sessionId || !signature || signature !== this.sign(sessionId)) {
       return null;
     }
-    const rows = await this.sql.unsafe(`SELECT s.id, s.user_id, s.expires_at, u.name, u.email
+    const rows = await this.sql.unsafe(`SELECT s.id, s.user_id, s.expires_at, u.name, u.email, u.learn_subscriber
        FROM sessions s
        INNER JOIN users u ON u.id = s.user_id
        WHERE s.id = $1 AND s.expires_at > NOW()`, [sessionId]);
     const row = rows[0];
     if (!row)
       return null;
-    return { id: row.user_id, name: row.name, email: row.email };
+    return {
+      id: row.user_id,
+      name: row.name,
+      email: row.email,
+      learn_subscriber: row.learn_subscriber
+    };
   }
   sign(value) {
     return createHash("sha256").update(`${value}.${this.secret}`).digest("hex").slice(0, 32);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/bootstrap",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Strata application bootstrap — HttpKernel, DI, web session helpers",
   "type": "module",
   "license": "MIT",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@getstrata/core": "^0.3.0",
+    "@getstrata/core": "^0.4.0",
     "typescript": "^5.9.0"
   }
 }