@rocksky/cli 0.1.1 → 0.3.0

package/src/schema/artist-albums.ts

@@ -0,0 +1,29 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import albums from "./albums";
+import artists from "./artists";
+
+const artistAlbums = sqliteTable(
+  "artist_albums",
+  {
+    id: text("id").primaryKey().notNull(),
+    artistId: text("artist_id")
+      .notNull()
+      .references(() => artists.id),
+    albumId: text("album_id")
+      .notNull()
+      .references(() => albums.id),
+    createdAt: integer("created_at")
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at")
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (t) => [unique("artist_albums_unique_index").on(t.artistId, t.albumId)],
+);
+
+export type SelectArtistAlbum = InferSelectModel<typeof artistAlbums>;
+export type InsertArtistAlbum = InferInsertModel<typeof artistAlbums>;
+
+export default artistAlbums;

package/src/schema/artist-genres.ts

@@ -0,0 +1,17 @@
+import { type InferInsertModel, type InferSelectModel } from "drizzle-orm";
+import { sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+
+const artistGenres = sqliteTable(
+  "artist_genres ",
+  {
+    id: text("id").primaryKey().notNull(),
+    artistId: text("artist_id").notNull(),
+    genreId: text("genre_id").notNull(),
+  },
+  (t) => [unique("artist_genre_unique_index").on(t.artistId, t.genreId)],
+);
+
+export type SelectArtistGenre = InferSelectModel<typeof artistGenres>;
+export type InsertArtistGenre = InferInsertModel<typeof artistGenres>;
+
+export default artistGenres;

package/src/schema/artist-tracks.ts

@@ -0,0 +1,29 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import artists from "./artists";
+import tracks from "./tracks";
+
+const artistTracks = sqliteTable(
+  "artist_tracks",
+  {
+    id: text("id").primaryKey().notNull(),
+    artistId: text("artist_id")
+      .notNull()
+      .references(() => artists.id),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => tracks.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (t) => [unique("artist_tracks_unique_index").on(t.artistId, t.trackId)],
+);
+
+export type SelectArtistTrack = InferSelectModel<typeof artistTracks>;
+export type InsertArtistTrack = InferInsertModel<typeof artistTracks>;
+
+export default artistTracks;

package/src/schema/artists.ts

@@ -0,0 +1,30 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const artists = sqliteTable("artists", {
+  id: text("id").primaryKey().notNull(),
+  name: text("name").notNull(),
+  biography: text("biography"),
+  born: integer("born", { mode: "timestamp" }),
+  bornIn: text("born_in"),
+  died: integer("died", { mode: "timestamp" }),
+  picture: text("picture"),
+  uri: text("uri").unique(),
+  cid: text("cid").unique().notNull(),
+  appleMusicLink: text("apple_music_link"),
+  spotifyLink: text("spotify_link"),
+  tidalLink: text("tidal_link"),
+  youtubeLink: text("youtube_link"),
+  genres: text("genres"),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectArtist = InferSelectModel<typeof artists>;
+export type InsertArtist = InferInsertModel<typeof artists>;
+
+export default artists;

package/src/schema/auth-session.ts

@@ -0,0 +1,18 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const authSessions = sqliteTable("auth_sessions", {
+  key: text("key").primaryKey().notNull(),
+  session: text("session").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectAuthSession = InferSelectModel<typeof authSessions>;
+export type InsertAuthSession = InferInsertModel<typeof authSessions>;
+
+export default authSessions;

package/src/schema/genres.ts

@@ -0,0 +1,18 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const genres = sqliteTable("genres", {
+  id: text("id").primaryKey().notNull(),
+  name: text("name").unique().notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectGenre = InferSelectModel<typeof genres>;
+export type InsertGenre = InferInsertModel<typeof genres>;
+
+export default genres;

package/src/schema/index.ts

@@ -0,0 +1,33 @@
+import albumTracks from "./album-tracks";
+import albums from "./albums";
+import artistAlbums from "./artist-albums";
+import artistGenres from "./artist-genres";
+import artistTracks from "./artist-tracks";
+import artists from "./artists";
+import authSessions from "./auth-session";
+import genres from "./genres";
+import lovedTracks from "./loved-tracks";
+import scrobbles from "./scrobbles";
+import tracks from "./tracks";
+import userAlbums from "./user-albums";
+import userArtists from "./user-artists";
+import userTracks from "./user-tracks";
+import users from "./users";
+
+export default {
+  users,
+  tracks,
+  artists,
+  albums,
+  albumTracks,
+  authSessions,
+  artistAlbums,
+  artistTracks,
+  lovedTracks,
+  scrobbles,
+  userAlbums,
+  userArtists,
+  userTracks,
+  genres,
+  artistGenres,
+};

package/src/schema/loved-tracks.ts

@@ -0,0 +1,27 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { sqliteTable, integer, text, unique } from "drizzle-orm/sqlite-core";
+import tracks from "./tracks";
+import users from "./users";
+
+const lovedTracks = sqliteTable(
+  "loved_tracks",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => tracks.id),
+    uri: text("uri").unique(),
+    createdAt: integer("created_at")
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (t) => [unique("loved_tracks_unique_index").on(t.userId, t.trackId)],
+);
+
+export type SelectLovedTrack = InferSelectModel<typeof lovedTracks>;
+export type InsertLovedTrack = InferInsertModel<typeof lovedTracks>;
+
+export default lovedTracks;

package/src/schema/scrobbles.ts

@@ -0,0 +1,30 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import albums from "./albums";
+import artists from "./artists";
+import tracks from "./tracks";
+import users from "./users";
+
+const scrobbles = sqliteTable("scrobbles", {
+  id: text("xata_id").primaryKey().notNull(),
+  userId: text("user_id").references(() => users.id),
+  trackId: text("track_id").references(() => tracks.id),
+  albumId: text("album_id").references(() => albums.id),
+  artistId: text("artist_id").references(() => artists.id),
+  uri: text("uri").unique(),
+  cid: text("cid").unique(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  timestamp: integer("timestamp", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectScrobble = InferSelectModel<typeof scrobbles>;
+export type InsertScrobble = InferInsertModel<typeof scrobbles>;
+
+export default scrobbles;

package/src/schema/tracks.ts

@@ -0,0 +1,39 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const tracks = sqliteTable("tracks", {
+  id: text("id").primaryKey().notNull(),
+  title: text("title").notNull(),
+  artist: text("artist").notNull(),
+  albumArtist: text("album_artist").notNull(),
+  albumArt: text("album_art"),
+  album: text("album").notNull(),
+  trackNumber: integer("track_number"),
+  duration: integer("duration").notNull(),
+  mbId: text("mb_id").unique(),
+  youtubeLink: text("youtube_link").unique(),
+  spotifyLink: text("spotify_link").unique(),
+  appleMusicLink: text("apple_music_link").unique(),
+  tidalLink: text("tidal_link").unique(),
+  discNumber: integer("disc_number"),
+  lyrics: text("lyrics"),
+  composer: text("composer"),
+  genre: text("genre"),
+  label: text("label"),
+  copyrightMessage: text("copyright_message"),
+  uri: text("uri").unique(),
+  cid: text("cid").unique().notNull(),
+  albumUri: text("album_uri"),
+  artistUri: text("artist_uri"),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectTrack = InferSelectModel<typeof tracks>;
+export type InsertTrack = InferInsertModel<typeof tracks>;
+
+export default tracks;

package/src/schema/user-albums.ts

@@ -0,0 +1,31 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import albums from "./albums";
+import users from "./users";
+
+const userAlbums = sqliteTable(
+  "user_albums",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    albumId: text("album_id")
+      .notNull()
+      .references(() => albums.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    scrobbles: integer("scrobbles"),
+    uri: text("uri").unique().notNull(),
+  },
+  (t) => [unique("user_albums_unique_index").on(t.userId, t.albumId)],
+);
+
+export type SelectUserAlbum = InferSelectModel<typeof userAlbums>;
+export type InsertUserAlbum = InferInsertModel<typeof userAlbums>;
+
+export default userAlbums;

package/src/schema/user-artists.ts

@@ -0,0 +1,32 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import artists from "./artists";
+import users from "./users";
+
+const userArtists = sqliteTable(
+  "user_artists",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    artistId: text("artist_id")
+      .notNull()
+      .references(() => artists.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    scrobbles: integer("scrobbles"),
+    uri: text("uri").unique().notNull(),
+  },
+
+  (t) => [unique("user_artists_unique_index").on(t.userId, t.artistId)],
+);
+
+export type SelectUserArtist = InferSelectModel<typeof userArtists>;
+export type InsertUserArtist = InferInsertModel<typeof userArtists>;
+
+export default userArtists;

package/src/schema/user-tracks.ts

@@ -0,0 +1,31 @@
+import { type InferInsertModel, type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import tracks from "./tracks";
+import users from "./users";
+
+const userTracks = sqliteTable(
+  "user_tracks",
+  {
+    id: text("id").primaryKey().notNull(),
+    userId: text("user_id")
+      .notNull()
+      .references(() => users.id),
+    trackId: text("track_id")
+      .notNull()
+      .references(() => tracks.id),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    scrobbles: integer("scrobbles"),
+    uri: text("uri").unique().notNull(),
+  },
+  (t) => [unique("user_tracks_unique_index").on(t.userId, t.trackId)],
+);
+
+export type SelectUser = InferSelectModel<typeof userTracks>;
+export type InsertUserTrack = InferInsertModel<typeof userTracks>;
+
+export default userTracks;

package/src/schema/users.ts

@@ -0,0 +1,21 @@
+import { type InferSelectModel, sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const users = sqliteTable("users", {
+  id: text("id").primaryKey().notNull(),
+  did: text("did").unique().notNull(),
+  displayName: text("display_name"),
+  handle: text("handle").unique().notNull(),
+  avatar: text("avatar").notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type SelectUser = InferSelectModel<typeof users>;
+export type InsertUser = InferSelectModel<typeof users>;
+
+export default users;