npm - @coursebuilder/adapter-drizzle - Versions diffs - 0.0.1 → 0.0.3 - Mend

@coursebuilder/adapter-drizzle 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/lib/sqlite.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
-import type { Adapter } from '@auth/core/adapters';
 import { BaseSQLiteDatabase, SQLiteTableFn } from 'drizzle-orm/sqlite-core';
+import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters';
 export declare function createTables(sqliteTable: SQLiteTableFn): {
     users: import("drizzle-orm/sqlite-core/table.js").SQLiteTableWithColumns<{
         name: "user";
@@ -29,6 +29,18 @@ export declare function createTables(sqliteTable: SQLiteTableFn): {
                 enumValues: [string, ...string[]];
                 baseColumn: never;
             }, object>;
+            role: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "role";
+                tableName: "user";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: "user" | "admin";
+                driverParam: string;
+                notNull: false;
+                hasDefault: true;
+                enumValues: ["user", "admin"];
+                baseColumn: never;
+            }, object>;
             email: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
                 name: "email";
                 tableName: "user";
@@ -293,7 +305,189 @@ export declare function createTables(sqliteTable: SQLiteTableFn): {
         };
         dialect: "sqlite";
     }>;
+    contentResource: import("drizzle-orm/sqlite-core/table.js").SQLiteTableWithColumns<{
+        name: "contentResource";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "id";
+                tableName: "contentResource";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, object>;
+            type: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "type";
+                tableName: "contentResource";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, object>;
+            createdById: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "createdById";
+                tableName: "contentResource";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, object>;
+            fields: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "metadata";
+                tableName: "contentResource";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, any>;
+                driverParam: string;
+                notNull: false;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            createdAt: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "createdAt";
+                tableName: "contentResource";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            updatedAt: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "updatedAt";
+                tableName: "contentResource";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            deletedAt: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "deletedAt";
+                tableName: "contentResource";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+        };
+        dialect: "sqlite";
+    }>;
+    contentResourceResource: import("drizzle-orm/sqlite-core/table.js").SQLiteTableWithColumns<{
+        name: "contentResourceResource";
+        schema: undefined;
+        columns: {
+            resourceOfId: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "resourceOfId";
+                tableName: "contentResourceResource";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, object>;
+            resourceId: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "resourceId";
+                tableName: "contentResourceResource";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+            }, object>;
+            position: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "position";
+                tableName: "contentResourceResource";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            metadata: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "metadata";
+                tableName: "contentResourceResource";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, any>;
+                driverParam: string;
+                notNull: false;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            createdAt: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "createdAt";
+                tableName: "contentResourceResource";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            updatedAt: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "updatedAt";
+                tableName: "contentResourceResource";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: true;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+            deletedAt: import("drizzle-orm/sqlite-core/index.js").SQLiteColumn<{
+                name: "deletedAt";
+                tableName: "contentResourceResource";
+                dataType: "date";
+                columnType: "SQLiteTimestamp";
+                data: Date;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+            }, object>;
+        };
+        dialect: "sqlite";
+    }>;
 };
 export type DefaultSchema = ReturnType<typeof createTables>;
-export declare function SQLiteDrizzleAdapter(client: InstanceType<typeof BaseSQLiteDatabase>, tableFn?: SQLiteTableFn<undefined>): Adapter;
+export declare function SQLiteDrizzleAdapter(client: InstanceType<typeof BaseSQLiteDatabase>, tableFn?: SQLiteTableFn<undefined>): CourseBuilderAdapter;
 //# sourceMappingURL=sqlite.d.ts.map

package/lib/sqlite.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"~~AAAA~~,OAAO,~~KAAK~~,~~EAAE~~,~~OAAO~~,~~EAAkB~~,MAAM,~~qBAAqB~~,CAAA;~~AAElE~~,OAAO,~~EACL~~,~~kBAAkB~~,~~EAIlB~~,~~aAAa~~,~~EAEd,~~MAAM,~~yBAAyB~~,CAAA;~~AAIhC~~,wBAAgB,YAAY,CAAC,WAAW,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDtD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,EAC/C,OAAO,2BAAuB,GAC7B,~~OAAO~~,~~CA+FT~~"}
1	+ {"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,kBAAkB,EAIlB,aAAa,EAEd,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAIxE,wBAAgB,YAAY,CAAC,WAAW,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2FtD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,EAC/C,OAAO,2BAAuB,GAC7B,oBAAoB,CAiHtB"}

package/lib/sqlite.js CHANGED Viewed

@@ -1,10 +1,11 @@
-import { and, eq } from 'drizzle-orm';
+import { and, eq, sql } from 'drizzle-orm';
 import { sqliteTable as defaultSqliteTableFn, integer, primaryKey, text, } from 'drizzle-orm/sqlite-core';
 import { stripUndefined } from './utils.js';
 export function createTables(sqliteTable) {
     const users = sqliteTable('user', {
         id: text('id').notNull().primaryKey(),
         name: text('name'),
+        role: text('role', { enum: ['user', 'admin'] }).default('user'),
         email: text('email').notNull(),
         emailVerified: integer('emailVerified', { mode: 'timestamp_ms' }),
         image: text('image'),
@@ -24,7 +25,7 @@ export function createTables(sqliteTable) {
         id_token: text('id_token'),
         session_state: text('session_state'),
     }, (account) => ({
-        compoundKey: primaryKey(account.provider, account.providerAccountId),
+        pk: primaryKey({ columns: [account.provider, account.providerAccountId] }),
     }));
     const sessions = sqliteTable('session', {
         sessionToken: text('sessionToken').notNull().primaryKey(),
@@ -38,13 +39,63 @@ export function createTables(sqliteTable) {
         token: text('token').notNull(),
         expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
     }, (vt) => ({
-        compoundKey: primaryKey(vt.identifier, vt.token),
+        pk: primaryKey({ columns: [vt.identifier, vt.token] }),
     }));
-    return { users, accounts, sessions, verificationTokens };
+    const contentResource = sqliteTable('contentResource', {
+        id: text('id', { length: 255 }).notNull().primaryKey(),
+        type: text('type', { length: 255 }).notNull(),
+        createdById: text('createdById', { length: 255 }).notNull(),
+        fields: text('metadata', { mode: 'json' }).$type().default({}),
+        createdAt: integer('createdAt', {
+            mode: 'timestamp_ms',
+        }).default(sql `CURRENT_TIME`),
+        updatedAt: integer('updatedAt', {
+            mode: 'timestamp_ms',
+        }).default(sql `CURRENT_TIME`),
+        deletedAt: integer('deletedAt', {
+            mode: 'timestamp_ms',
+        }),
+    });
+    const contentResourceResource = sqliteTable('contentResourceResource', {
+        resourceOfId: text('resourceOfId', { length: 255 }).notNull(),
+        resourceId: text('resourceId', { length: 255 }).notNull(),
+        position: integer('position').notNull().default(0),
+        metadata: text('metadata', { mode: 'json' }).$type().default({}),
+        createdAt: integer('createdAt', {
+            mode: 'timestamp_ms',
+        }).default(sql `CURRENT_TIME`),
+        updatedAt: integer('updatedAt', {
+            mode: 'timestamp_ms',
+        }).default(sql `CURRENT_TIME`),
+        deletedAt: integer('deletedAt', {
+            mode: 'timestamp_ms',
+        }),
+    }, (crr) => ({
+        pk: primaryKey({ columns: [crr.resourceOfId, crr.resourceId] }),
+    }));
+    return { users, accounts, sessions, verificationTokens, contentResource, contentResourceResource };
 }
 export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
-    const { users, accounts, sessions, verificationTokens } = createTables(tableFn);
+    const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn);
     return {
+        async updateContentResourceFields(options) {
+            return null;
+        },
+        async getVideoResource(id) {
+            //  TODO Implement
+            return null;
+        },
+        async createContentResource(resource) {
+            return client
+                .insert(contentResource)
+                .values({ ...resource, id: crypto.randomUUID() })
+                .returning()
+                .get();
+        },
+        async getContentResource(data) {
+            const result = await client.select().from(contentResource).where(eq(contentResource.id, data)).get();
+            return result ?? null;
+        },
         async createUser(data) {
             return client
                 .insert(users)

package/lib/utils.d.ts CHANGED Viewed

@@ -1,8 +1,8 @@
-import { MySqlDatabase } from 'drizzle-orm/mysql-core';
+import { type MySqlDatabase } from 'drizzle-orm/mysql-core';
 import type { AnyMySqlTable, MySqlTableFn } from 'drizzle-orm/mysql-core';
-import { PgDatabase } from 'drizzle-orm/pg-core';
+import { type PgDatabase } from 'drizzle-orm/pg-core';
 import type { AnyPgTable, PgTableFn } from 'drizzle-orm/pg-core';
-import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { type BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
 import type { AnySQLiteTable, SQLiteTableFn } from 'drizzle-orm/sqlite-core';
 import type { DefaultSchema as MySqlSchema } from './mysql.js';
 import type { DefaultSchema as PgSchema } from './pg.js';

package/lib/utils.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;~~AACtD~~,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;~~AAChD~~,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;~~AAC5D~~,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAE5E,OAAO,KAAK,EAAE,aAAa,IAAI,WAAW,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,IAAI,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAEtE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAClD,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACzC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACtD;AAED,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAEnF,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GAC/D,aAAa,CAAC,OAAO,CAAC,GACtB,MAAM,SAAS,aAAa,GAC1B,aAAa,CAAC,IAAI,CAAC,GACnB,MAAM,SAAS,iBAAiB,GAC9B,aAAa,CAAC,QAAQ,CAAC,GACvB,KAAK,CAAA;AAEb,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GACzD,YAAY,GACZ,MAAM,SAAS,aAAa,GAC1B,SAAS,GACT,MAAM,SAAS,iBAAiB,GAC9B,aAAa,GACb,cAAc,CAAA;AAEtB,KAAK,gBAAgB,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC;CAC9C,CAAC,MAAM,CAAC,CAAC,CAAA;AAEV,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAItE"}
1	+ {"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAE5E,OAAO,KAAK,EAAE,aAAa,IAAI,WAAW,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,IAAI,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAEtE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAClD,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACzC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACtD;AAED,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG,aAAa,GAAG,iBAAiB,CAAA;AAEnF,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GAC/D,aAAa,CAAC,OAAO,CAAC,GACtB,MAAM,SAAS,aAAa,GAC1B,aAAa,CAAC,IAAI,CAAC,GACnB,MAAM,SAAS,iBAAiB,GAC9B,aAAa,CAAC,QAAQ,CAAC,GACvB,KAAK,CAAA;AAEb,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GACzD,YAAY,GACZ,MAAM,SAAS,aAAa,GAC1B,SAAS,GACT,MAAM,SAAS,iBAAiB,GAC9B,aAAa,GACb,cAAc,CAAA;AAEtB,KAAK,gBAAgB,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC;CAC9C,CAAC,MAAM,CAAC,CAAC,CAAA;AAEV,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAItE"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@coursebuilder/adapter-drizzle",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Drizzle adapter for Course Builder.",
   "keywords": [
     "coursebuilder",
@@ -27,11 +27,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@auth/core": "^0.28.0",
-    "@coursebuilder/core": "0.0.1",
     "date-fns": "^2.30.0"
   },
   "devDependencies": {
+    "@auth/core": "^0.28.0",
+    "@coursebuilder/core": "0.0.3",
     "@libsql/client": "0.5.6",
     "@types/better-sqlite3": "7.6.9",
     "@types/uuid": "9.0.8",
@@ -41,12 +41,11 @@
     "mysql2": "^3.6.1",
     "postgres": "^3.3.4"
   },
+  "peerDependencies": {
+    "drizzle-orm": "0.30.x"
+  },
   "scripts": {
     "clean": "rm -rf ./dist",
-    "test": "pnpm test:mysql && pnpm test:sqlite && pnpm test:pg",
-    "test:mysql": "pnpm clean && ./test/mysql/test.sh",
-    "test:sqlite": "pnpm clean && ./test/sqlite/test.sh",
-    "test:pg": "pnpm clean && ./test/pg/test.sh",
     "build": "tsc",
     "dev": "tsc --watch"
   }

package/src/index.ts CHANGED Viewed

@@ -1,19 +1,19 @@
 import { is } from 'drizzle-orm'
-import { MySqlDatabase, MySqlTableFn } from 'drizzle-orm/mysql-core'
-import { PgDatabase, PgTableFn } from 'drizzle-orm/pg-core'
-import { BaseSQLiteDatabase, SQLiteTableFn } from 'drizzle-orm/sqlite-core'
+import { MySqlDatabase, type MySqlTableFn } from 'drizzle-orm/mysql-core'
+import { PgDatabase, type PgTableFn } from 'drizzle-orm/pg-core'
+import { BaseSQLiteDatabase, type SQLiteTableFn } from 'drizzle-orm/sqlite-core'
+import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
 import { createTables as createMySqlTables, mySqlDrizzleAdapter } from './lib/mysql.js'
 import { pgDrizzleAdapter } from './lib/pg.js'
 import { SQLiteDrizzleAdapter } from './lib/sqlite.js'
-import { SqlFlavorOptions, TableFn } from './lib/utils.js'
-type NO_IT_AINT = any
+import { type SqlFlavorOptions, type TableFn } from './lib/utils.js'
 export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
   db: SqlFlavor,
   table?: TableFn<SqlFlavor>,
-): NO_IT_AINT {
+): CourseBuilderAdapter {
   if (is(db, MySqlDatabase)) {
     return mySqlDrizzleAdapter(db, table as MySqlTableFn)
   } else if (is(db, PgDatabase)) {

package/src/lib/mysql.ts CHANGED Viewed

@@ -15,7 +15,8 @@ import {
   varchar,
 } from 'drizzle-orm/mysql-core'
-import { CourseBuilderAdapter } from '@coursebuilder/core/adapters'
+import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
+import { VideoResourceSchema } from '@coursebuilder/core/schemas/video-resource'
 export function createTables(mySqlTable: MySqlTableFn) {
   const users = mySqlTable('user', {
@@ -151,6 +152,63 @@ export function mySqlDrizzleAdapter(
   const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn)
   return {
+    async updateContentResourceFields(options) {
+      const setFields = Object.entries(options.fields)
+        .map(([fieldName, fieldValue], index, array) => {
+          const comma = index < array.length - 1 ? ',' : ''
+          return sql`${fieldName} = ${fieldValue}${comma}`
+        })
+        .join(' ')
+      const query = sql`
+        UPDATE ${contentResource}
+        SET ${setFields}
+        WHERE
+          id = ${options.id};
+      `
+      return client
+        .execute(query)
+        .then((_) => {
+          return this.getContentResource(options.id)
+        })
+        .catch((error) => {
+          console.error(error)
+          throw error
+        })
+    },
+    async getVideoResource(id) {
+      if (!id) {
+        throw new Error('videoResourceId is required')
+      }
+      const query = sql`
+    SELECT
+      id as _id,
+      CAST(updatedAt AS DATETIME) as _updatedAt,
+      CAST(createdAt AS DATETIME) as _createdAt,
+      JSON_EXTRACT (${contentResource.fields}, "$.state") AS state,
+      JSON_EXTRACT (${contentResource.fields}, "$.duration") AS duration,
+      JSON_EXTRACT (${contentResource.fields}, "$.muxPlaybackId") AS muxPlaybackId,
+      JSON_EXTRACT (${contentResource.fields}, "$.muxAssetId") AS muxAssetId,
+      JSON_EXTRACT (${contentResource.fields}, "$.transcript") AS transcript
+    FROM
+      ${contentResource}
+    WHERE
+      type = 'videoResource'
+      AND (id = ${id});
+ `
+      return client
+        .execute(query)
+        .then((result: any) => {
+          const parsedResource = VideoResourceSchema.safeParse(result.rows[0])
+          return parsedResource.success ? parsedResource.data : null
+        })
+        .catch((error) => {
+          console.error(error)
+          return error
+        })
+    },
     async createContentResource(data) {
       const id = crypto.randomUUID()

package/src/lib/pg.ts CHANGED Viewed

@@ -1,16 +1,19 @@
-import type { Adapter, AdapterAccount, AdapterSession, AdapterUser } from '@auth/core/adapters'
+import type { AdapterAccount, AdapterSession, AdapterUser } from '@auth/core/adapters'
 import { and, eq } from 'drizzle-orm'
 import {
   pgTable as defaultPgTableFn,
   integer,
+  json,
   PgDatabase,
+  pgEnum,
   PgTableFn,
   primaryKey,
   text,
   timestamp,
+  varchar,
 } from 'drizzle-orm/pg-core'
-import { stripUndefined } from './utils.js'
+import { type CourseBuilderAdapter } from '@coursebuilder/core/adapters'
 export function createTables(pgTable: PgTableFn) {
   const users = pgTable('user', {
@@ -18,6 +21,7 @@ export function createTables(pgTable: PgTableFn) {
     name: text('name'),
     email: text('email').notNull(),
     emailVerified: timestamp('emailVerified', { mode: 'date' }),
+    role: pgEnum('role', ['user', 'admin'])('role').default('user'),
     image: text('image'),
   })
@@ -39,7 +43,7 @@ export function createTables(pgTable: PgTableFn) {
       session_state: text('session_state'),
     },
     (account) => ({
-      compoundKey: primaryKey(account.provider, account.providerAccountId),
+      pk: primaryKey({ columns: [account.provider, account.providerAccountId] }),
     }),
   )
@@ -59,19 +63,94 @@ export function createTables(pgTable: PgTableFn) {
       expires: timestamp('expires', { mode: 'date' }).notNull(),
     },
     (vt) => ({
-      compoundKey: primaryKey(vt.identifier, vt.token),
+      pk: primaryKey({ columns: [vt.identifier, vt.token] }),
     }),
   )
-  return { users, accounts, sessions, verificationTokens }
+  const contentResource = pgTable('contentResource', {
+    id: varchar('id', { length: 255 }).notNull().primaryKey(),
+    type: varchar('type', { length: 255 }).notNull(),
+    createdById: varchar('createdById', { length: 255 }).notNull(),
+    fields: json('fields').$type<Record<string, any>>().default({}),
+    createdAt: timestamp('createdAt', {
+      mode: 'date',
+      precision: 6,
+      withTimezone: true,
+    }).defaultNow(),
+    updatedAt: timestamp('updatedAt', {
+      mode: 'date',
+      precision: 6,
+      withTimezone: true,
+    }).defaultNow(),
+    deletedAt: timestamp('deletedAt', {
+      mode: 'date',
+      precision: 6,
+      withTimezone: true,
+    }),
+  })
+  const contentResourceResource = pgTable(
+    'contentResourceResource',
+    {
+      resourceOfId: varchar('resourceOfId', { length: 255 }).notNull(),
+      resourceId: varchar('resourceId', { length: 255 }).notNull(),
+      position: integer('position').notNull().default(0),
+      metadata: json('fields').$type<Record<string, any>>().default({}),
+      createdAt: timestamp('createdAt', {
+        mode: 'date',
+        precision: 6,
+        withTimezone: true,
+      }).defaultNow(),
+      updatedAt: timestamp('updatedAt', {
+        mode: 'date',
+        precision: 6,
+        withTimezone: true,
+      }).defaultNow(),
+      deletedAt: timestamp('deletedAt', {
+        mode: 'date',
+        precision: 6,
+        withTimezone: true,
+      }),
+    },
+    (crr) => ({
+      pk: primaryKey({ columns: [crr.resourceOfId, crr.resourceId] }),
+    }),
+  )
+  return { users, accounts, sessions, verificationTokens, contentResource }
 }
 export type DefaultSchema = ReturnType<typeof createTables>
-export function pgDrizzleAdapter(client: InstanceType<typeof PgDatabase>, tableFn = defaultPgTableFn): Adapter {
-  const { users, accounts, sessions, verificationTokens } = createTables(tableFn)
+export function pgDrizzleAdapter(
+  client: InstanceType<typeof PgDatabase>,
+  tableFn = defaultPgTableFn,
+): CourseBuilderAdapter {
+  const { users, accounts, sessions, verificationTokens, contentResource } = createTables(tableFn)
   return {
+    async updateContentResourceFields(options) {
+      return null
+    },
+    async getVideoResource(id) {
+      //  TODO Implement
+      return null
+    },
+    async createContentResource(resource) {
+      return client
+        .insert(contentResource)
+        .values({ ...resource, id: crypto.randomUUID() })
+        .returning()
+        .then((res) => res[0] ?? null)
+    },
+    async getContentResource(data) {
+      const result = await client
+        .select()
+        .from(contentResource)
+        .where(eq(contentResource.id, data))
+        .then((res) => res[0] ?? null)
+      return result ?? null
+    },
     async createUser(data) {
       return await client
         .insert(users)